@baron1996/kline-scene-schema 0.2.2 → 0.3.0

package/dist/generated/validate-time-series-scene.js

@@ -0,0 +1,2359 @@
+// @ts-nocheck -- generated standalone validator
+"use strict";
+export const validateTimeSeriesScene = validate20;
+const schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://baron.dev/kline-scene/time-series-scene.schema.json", "title": "TimeSeriesScene", "type": "object", "additionalProperties": false, "required": ["schema", "version", "runtime", "period", "series", "data", "chart", "viewport", "render", "metadata"], "properties": { "schema": { "const": "@baron1996/time-series-scene" }, "version": { "const": 1 }, "runtime": { "$ref": "https://baron.dev/kline-scene/time-series-runtime.schema.json" }, "period": { "$ref": "#/$defs/timeSeriesPeriod" }, "series": { "type": "array", "minItems": 1, "maxItems": 64, "items": { "$ref": "#/$defs/timeSeriesDefinition" } }, "data": { "type": "array", "minItems": 1, "maxItems": 1000000, "items": { "$ref": "#/$defs/timeSeriesPoint" } }, "chart": { "$ref": "https://baron.dev/kline-scene/time-series-chart-config.schema.json" }, "viewport": { "$ref": "#/$defs/timeSeriesViewport" }, "render": { "$ref": "#/$defs/timeSeriesRender" }, "metadata": { "$ref": "#/$defs/metadata" } }, "$defs": { "timeSeriesPeriod": { "type": "object", "additionalProperties": false, "required": ["span", "type"], "properties": { "span": { "type": "integer", "minimum": 1, "maximum": 100000 }, "type": { "enum": ["second", "minute", "hour", "day", "week", "month", "year"] } } }, "timeSeriesDefinition": { "type": "object", "additionalProperties": false, "required": ["id", "name", "type", "unit", "precision", "visible", "style"], "properties": { "id": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }, "name": { "type": "string", "minLength": 1, "maxLength": 256 }, "type": { "const": "line" }, "unit": { "type": "string", "minLength": 1, "maxLength": 64 }, "precision": { "type": "integer", "minimum": 0, "maximum": 16 }, "visible": { "type": "boolean" }, "style": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/lineStyle" } } }, "timeSeriesPoint": { "type": "object", "additionalProperties": false, "required": ["timestamp", "values"], "properties": { "timestamp": { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, "values": { "type": "object", "minProperties": 1, "maxProperties": 64, "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }, "additionalProperties": { "oneOf": [{ "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber" }, { "type": "null" }] } } } }, "timeSeriesViewport": { "type": "object", "additionalProperties": false, "required": ["barSpace", "rightOffsetDistance", "anchorTimestamp"], "properties": { "barSpace": { "type": "number", "minimum": 1, "maximum": 100 }, "rightOffsetDistance": { "type": "number", "minimum": 0, "maximum": 10000 }, "anchorTimestamp": { "type": "integer", "minimum": 1, "maximum": 9007199254740991 } } }, "timeSeriesRender": { "type": "object", "additionalProperties": false, "required": ["width", "height", "deviceScaleFactor", "background", "fontFamily", "timeoutMs"], "properties": { "width": { "type": "integer", "minimum": 320, "maximum": 8192 }, "height": { "type": "integer", "minimum": 240, "maximum": 8192 }, "deviceScaleFactor": { "type": "number", "minimum": 0.5, "maximum": 4 }, "background": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor" }, "fontFamily": { "const": "Baron Sans" }, "timeoutMs": { "type": "integer", "minimum": 100, "maximum": 120000 } } }, "metadata": { "type": "object", "maxProperties": 64, "propertyNames": { "type": "string", "minLength": 1, "maxLength": 128 }, "additionalProperties": { "oneOf": [{ "type": "null" }, { "type": "boolean" }, { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber" }, { "type": "string" }] } } } };
+const schema32 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://baron.dev/kline-scene/time-series-runtime.schema.json", "title": "TimeSeriesRuntimeIdentity", "type": "object", "additionalProperties": false, "required": ["engine", "engineVersion", "runtimeVersion"], "properties": { "engine": { "const": "klinecharts" }, "engineVersion": { "const": "10.0.0" }, "runtimeVersion": { "const": "0.1.0" } } };
+const schema33 = { "type": "object", "additionalProperties": false, "required": ["span", "type"], "properties": { "span": { "type": "integer", "minimum": 1, "maximum": 100000 }, "type": { "enum": ["second", "minute", "hour", "day", "week", "month", "year"] } } };
+const schema45 = { "type": "object", "additionalProperties": false, "required": ["barSpace", "rightOffsetDistance", "anchorTimestamp"], "properties": { "barSpace": { "type": "number", "minimum": 1, "maximum": 100 }, "rightOffsetDistance": { "type": "number", "minimum": 0, "maximum": 10000 }, "anchorTimestamp": { "type": "integer", "minimum": 1, "maximum": 9007199254740991 } } };
+const func1 = Object.prototype.hasOwnProperty;
+const schema34 = { "type": "object", "additionalProperties": false, "required": ["id", "name", "type", "unit", "precision", "visible", "style"], "properties": { "id": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }, "name": { "type": "string", "minLength": 1, "maxLength": 256 }, "type": { "const": "line" }, "unit": { "type": "string", "minLength": 1, "maxLength": 64 }, "precision": { "type": "integer", "minimum": 0, "maximum": 16 }, "visible": { "type": "boolean" }, "style": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/lineStyle" } } };
+const pattern4 = new RegExp("^[A-Za-z][A-Za-z0-9_-]{0,63}$", "u");
+const func2 = (value) => { let length = 0; for (const _character of value)
+    length++; return length; };
+const schema36 = { "type": "object", "additionalProperties": false, "required": ["color", "size", "style"], "properties": { "color": { "$ref": "#/$defs/rgbaColor" }, "size": { "type": "number", "exclusiveMinimum": 0, "maximum": 20 }, "style": { "enum": ["solid", "dashed", "dotted"] } } };
+const schema37 = { "type": "string", "pattern": "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" };
+const pattern5 = new RegExp("^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$", "u");
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate23.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.color === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "color" }, message: "must have required property '" + "color" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.size === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "size" }, message: "must have required property '" + "size" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.style === undefined) {
+        const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "style" }, message: "must have required property '" + "style" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(((key0 === "color") || (key0 === "size")) || (key0 === "style"))) {
+            const err3 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+    }
+    if (data.color !== undefined) {
+        let data0 = data.color;
+        if (typeof data0 === "string") {
+            if (!pattern5.test(data0)) {
+                const err4 = { instancePath: instancePath + "/color", schemaPath: "#/$defs/rgbaColor/pattern", keyword: "pattern", params: { pattern: "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" }, message: "must match pattern \"" + "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" + "\"" };
+                if (vErrors === null) {
+                    vErrors = [err4];
+                }
+                else {
+                    vErrors.push(err4);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err5 = { instancePath: instancePath + "/color", schemaPath: "#/$defs/rgbaColor/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err5];
+            }
+            else {
+                vErrors.push(err5);
+            }
+            errors++;
+        }
+    }
+    if (data.size !== undefined) {
+        let data1 = data.size;
+        if ((typeof data1 == "number") && (isFinite(data1))) {
+            if (data1 > 20 || isNaN(data1)) {
+                const err6 = { instancePath: instancePath + "/size", schemaPath: "#/properties/size/maximum", keyword: "maximum", params: { comparison: "<=", limit: 20 }, message: "must be <= 20" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+            if (data1 <= 0 || isNaN(data1)) {
+                const err7 = { instancePath: instancePath + "/size", schemaPath: "#/properties/size/exclusiveMinimum", keyword: "exclusiveMinimum", params: { comparison: ">", limit: 0 }, message: "must be > 0" };
+                if (vErrors === null) {
+                    vErrors = [err7];
+                }
+                else {
+                    vErrors.push(err7);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err8 = { instancePath: instancePath + "/size", schemaPath: "#/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+    if (data.style !== undefined) {
+        let data2 = data.style;
+        if (!(((data2 === "solid") || (data2 === "dashed")) || (data2 === "dotted"))) {
+            const err9 = { instancePath: instancePath + "/style", schemaPath: "#/properties/style/enum", keyword: "enum", params: { allowedValues: schema36.properties.style.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+                vErrors = [err9];
+            }
+            else {
+                vErrors.push(err9);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err10 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err10];
+    }
+    else {
+        vErrors.push(err10);
+    }
+    errors++;
+} validate23.errors = vErrors; return errors === 0; }
+validate23.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate21.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.id === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property '" + "id" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.name === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property '" + "name" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.type === undefined) {
+        const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property '" + "type" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    if (data.unit === undefined) {
+        const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "unit" }, message: "must have required property '" + "unit" + "'" };
+        if (vErrors === null) {
+            vErrors = [err3];
+        }
+        else {
+            vErrors.push(err3);
+        }
+        errors++;
+    }
+    if (data.precision === undefined) {
+        const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "precision" }, message: "must have required property '" + "precision" + "'" };
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+    }
+    if (data.visible === undefined) {
+        const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "visible" }, message: "must have required property '" + "visible" + "'" };
+        if (vErrors === null) {
+            vErrors = [err5];
+        }
+        else {
+            vErrors.push(err5);
+        }
+        errors++;
+    }
+    if (data.style === undefined) {
+        const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "style" }, message: "must have required property '" + "style" + "'" };
+        if (vErrors === null) {
+            vErrors = [err6];
+        }
+        else {
+            vErrors.push(err6);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(((((((key0 === "id") || (key0 === "name")) || (key0 === "type")) || (key0 === "unit")) || (key0 === "precision")) || (key0 === "visible")) || (key0 === "style"))) {
+            const err7 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err7];
+            }
+            else {
+                vErrors.push(err7);
+            }
+            errors++;
+        }
+    }
+    if (data.id !== undefined) {
+        let data0 = data.id;
+        if (typeof data0 === "string") {
+            if (!pattern4.test(data0)) {
+                const err8 = { instancePath: instancePath + "/id", schemaPath: "#/properties/id/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }, message: "must match pattern \"" + "^[A-Za-z][A-Za-z0-9_-]{0,63}$" + "\"" };
+                if (vErrors === null) {
+                    vErrors = [err8];
+                }
+                else {
+                    vErrors.push(err8);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err9 = { instancePath: instancePath + "/id", schemaPath: "#/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err9];
+            }
+            else {
+                vErrors.push(err9);
+            }
+            errors++;
+        }
+    }
+    if (data.name !== undefined) {
+        let data1 = data.name;
+        if (typeof data1 === "string") {
+            if (func2(data1) > 256) {
+                const err10 = { instancePath: instancePath + "/name", schemaPath: "#/properties/name/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" };
+                if (vErrors === null) {
+                    vErrors = [err10];
+                }
+                else {
+                    vErrors.push(err10);
+                }
+                errors++;
+            }
+            if (func2(data1) < 1) {
+                const err11 = { instancePath: instancePath + "/name", schemaPath: "#/properties/name/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                    vErrors = [err11];
+                }
+                else {
+                    vErrors.push(err11);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err12 = { instancePath: instancePath + "/name", schemaPath: "#/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err12];
+            }
+            else {
+                vErrors.push(err12);
+            }
+            errors++;
+        }
+    }
+    if (data.type !== undefined) {
+        if ("line" !== data.type) {
+            const err13 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "line" }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err13];
+            }
+            else {
+                vErrors.push(err13);
+            }
+            errors++;
+        }
+    }
+    if (data.unit !== undefined) {
+        let data3 = data.unit;
+        if (typeof data3 === "string") {
+            if (func2(data3) > 64) {
+                const err14 = { instancePath: instancePath + "/unit", schemaPath: "#/properties/unit/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters" };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+            if (func2(data3) < 1) {
+                const err15 = { instancePath: instancePath + "/unit", schemaPath: "#/properties/unit/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                    vErrors = [err15];
+                }
+                else {
+                    vErrors.push(err15);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err16 = { instancePath: instancePath + "/unit", schemaPath: "#/properties/unit/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err16];
+            }
+            else {
+                vErrors.push(err16);
+            }
+            errors++;
+        }
+    }
+    if (data.precision !== undefined) {
+        let data4 = data.precision;
+        if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
+            const err17 = { instancePath: instancePath + "/precision", schemaPath: "#/properties/precision/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+                vErrors = [err17];
+            }
+            else {
+                vErrors.push(err17);
+            }
+            errors++;
+        }
+        if ((typeof data4 == "number") && (isFinite(data4))) {
+            if (data4 > 16 || isNaN(data4)) {
+                const err18 = { instancePath: instancePath + "/precision", schemaPath: "#/properties/precision/maximum", keyword: "maximum", params: { comparison: "<=", limit: 16 }, message: "must be <= 16" };
+                if (vErrors === null) {
+                    vErrors = [err18];
+                }
+                else {
+                    vErrors.push(err18);
+                }
+                errors++;
+            }
+            if (data4 < 0 || isNaN(data4)) {
+                const err19 = { instancePath: instancePath + "/precision", schemaPath: "#/properties/precision/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                if (vErrors === null) {
+                    vErrors = [err19];
+                }
+                else {
+                    vErrors.push(err19);
+                }
+                errors++;
+            }
+        }
+    }
+    if (data.visible !== undefined) {
+        if (typeof data.visible !== "boolean") {
+            const err20 = { instancePath: instancePath + "/visible", schemaPath: "#/properties/visible/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+            if (vErrors === null) {
+                vErrors = [err20];
+            }
+            else {
+                vErrors.push(err20);
+            }
+            errors++;
+        }
+    }
+    if (data.style !== undefined) {
+        if (!(validate23(data.style, { instancePath: instancePath + "/style", parentData: data, parentDataProperty: "style", rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
+            errors = vErrors.length;
+        }
+    }
+}
+else {
+    const err21 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err21];
+    }
+    else {
+        vErrors.push(err21);
+    }
+    errors++;
+} validate21.errors = vErrors; return errors === 0; }
+validate21.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+const schema38 = { "type": "object", "additionalProperties": false, "required": ["timestamp", "values"], "properties": { "timestamp": { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, "values": { "type": "object", "minProperties": 1, "maxProperties": 64, "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }, "additionalProperties": { "oneOf": [{ "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber" }, { "type": "null" }] } } } };
+const schema39 = { "type": "number", "minimum": -1.7976931348623157e+308, "maximum": 1.7976931348623157e+308 };
+function validate26(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate26.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.timestamp === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "timestamp" }, message: "must have required property '" + "timestamp" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.values === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "values" }, message: "must have required property '" + "values" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!((key0 === "timestamp") || (key0 === "values"))) {
+            const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err2];
+            }
+            else {
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+    if (data.timestamp !== undefined) {
+        let data0 = data.timestamp;
+        if (!(((typeof data0 == "number") && (!(data0 % 1) && !isNaN(data0))) && (isFinite(data0)))) {
+            const err3 = { instancePath: instancePath + "/timestamp", schemaPath: "#/properties/timestamp/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+        if ((typeof data0 == "number") && (isFinite(data0))) {
+            if (data0 > 9007199254740991 || isNaN(data0)) {
+                const err4 = { instancePath: instancePath + "/timestamp", schemaPath: "#/properties/timestamp/maximum", keyword: "maximum", params: { comparison: "<=", limit: 9007199254740991 }, message: "must be <= 9007199254740991" };
+                if (vErrors === null) {
+                    vErrors = [err4];
+                }
+                else {
+                    vErrors.push(err4);
+                }
+                errors++;
+            }
+            if (data0 < 1 || isNaN(data0)) {
+                const err5 = { instancePath: instancePath + "/timestamp", schemaPath: "#/properties/timestamp/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                if (vErrors === null) {
+                    vErrors = [err5];
+                }
+                else {
+                    vErrors.push(err5);
+                }
+                errors++;
+            }
+        }
+    }
+    if (data.values !== undefined) {
+        let data1 = data.values;
+        if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+            if (Object.keys(data1).length > 64) {
+                const err6 = { instancePath: instancePath + "/values", schemaPath: "#/properties/values/maxProperties", keyword: "maxProperties", params: { limit: 64 }, message: "must NOT have more than 64 properties" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+            if (Object.keys(data1).length < 1) {
+                const err7 = { instancePath: instancePath + "/values", schemaPath: "#/properties/values/minProperties", keyword: "minProperties", params: { limit: 1 }, message: "must NOT have fewer than 1 properties" };
+                if (vErrors === null) {
+                    vErrors = [err7];
+                }
+                else {
+                    vErrors.push(err7);
+                }
+                errors++;
+            }
+            for (const key1 in data1) {
+                const _errs6 = errors;
+                if (typeof key1 === "string") {
+                    if (!pattern4.test(key1)) {
+                        const err8 = { instancePath: instancePath + "/values", schemaPath: "#/properties/values/propertyNames/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }, message: "must match pattern \"" + "^[A-Za-z][A-Za-z0-9_-]{0,63}$" + "\"", propertyName: key1 };
+                        if (vErrors === null) {
+                            vErrors = [err8];
+                        }
+                        else {
+                            vErrors.push(err8);
+                        }
+                        errors++;
+                    }
+                }
+                var valid1 = _errs6 === errors;
+                if (!valid1) {
+                    const err9 = { instancePath: instancePath + "/values", schemaPath: "#/properties/values/propertyNames", keyword: "propertyNames", params: { propertyName: key1 }, message: "property name must be valid" };
+                    if (vErrors === null) {
+                        vErrors = [err9];
+                    }
+                    else {
+                        vErrors.push(err9);
+                    }
+                    errors++;
+                }
+            }
+            for (const key2 in data1) {
+                let data2 = data1[key2];
+                const _errs9 = errors;
+                let valid3 = false;
+                let passing0 = null;
+                const _errs10 = errors;
+                if ((typeof data2 == "number") && (isFinite(data2))) {
+                    if (data2 > 1.7976931348623157e+308 || isNaN(data2)) {
+                        const err10 = { instancePath: instancePath + "/values/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1.7976931348623157e+308 }, message: "must be <= 1.7976931348623157e+308" };
+                        if (vErrors === null) {
+                            vErrors = [err10];
+                        }
+                        else {
+                            vErrors.push(err10);
+                        }
+                        errors++;
+                    }
+                    if (data2 < -1.7976931348623157e+308 || isNaN(data2)) {
+                        const err11 = { instancePath: instancePath + "/values/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber/minimum", keyword: "minimum", params: { comparison: ">=", limit: -1.7976931348623157e+308 }, message: "must be >= -1.7976931348623157e+308" };
+                        if (vErrors === null) {
+                            vErrors = [err11];
+                        }
+                        else {
+                            vErrors.push(err11);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err12 = { instancePath: instancePath + "/values/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                        vErrors = [err12];
+                    }
+                    else {
+                        vErrors.push(err12);
+                    }
+                    errors++;
+                }
+                var _valid0 = _errs10 === errors;
+                if (_valid0) {
+                    valid3 = true;
+                    passing0 = 0;
+                }
+                const _errs13 = errors;
+                if (data2 !== null) {
+                    const err13 = { instancePath: instancePath + "/values/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/values/additionalProperties/oneOf/1/type", keyword: "type", params: { type: "null" }, message: "must be null" };
+                    if (vErrors === null) {
+                        vErrors = [err13];
+                    }
+                    else {
+                        vErrors.push(err13);
+                    }
+                    errors++;
+                }
+                var _valid0 = _errs13 === errors;
+                if (_valid0 && valid3) {
+                    valid3 = false;
+                    passing0 = [passing0, 1];
+                }
+                else {
+                    if (_valid0) {
+                        valid3 = true;
+                        passing0 = 1;
+                    }
+                }
+                if (!valid3) {
+                    const err14 = { instancePath: instancePath + "/values/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/values/additionalProperties/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+                    if (vErrors === null) {
+                        vErrors = [err14];
+                    }
+                    else {
+                        vErrors.push(err14);
+                    }
+                    errors++;
+                }
+                else {
+                    errors = _errs9;
+                    if (vErrors !== null) {
+                        if (_errs9) {
+                            vErrors.length = _errs9;
+                        }
+                        else {
+                            vErrors = null;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const err15 = { instancePath: instancePath + "/values", schemaPath: "#/properties/values/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err15];
+            }
+            else {
+                vErrors.push(err15);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err16 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err16];
+    }
+    else {
+        vErrors.push(err16);
+    }
+    errors++;
+} validate26.errors = vErrors; return errors === 0; }
+validate26.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+const schema40 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://baron.dev/kline-scene/time-series-chart-config.schema.json", "title": "TimeSeriesChartConfig", "type": "object", "additionalProperties": false, "required": ["locale", "timezone", "layout", "grid", "thousandsSeparator", "decimalFold", "zoomAnchor", "dateFormat", "largeNumberFormat"], "properties": { "locale": { "type": "string", "minLength": 2, "maxLength": 64, "pattern": "^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$" }, "timezone": { "type": "string", "minLength": 1, "maxLength": 128, "pattern": "^[A-Za-z_+-]+(?:/[A-Za-z0-9_+-]+)*$" }, "layout": { "type": "object", "additionalProperties": false, "required": ["backgroundColor", "textColor", "fontFamily", "fontSize"], "properties": { "backgroundColor": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor" }, "textColor": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor" }, "fontFamily": { "type": "string", "minLength": 1, "maxLength": 128 }, "fontSize": { "type": "number", "minimum": 8, "maximum": 32 } } }, "grid": { "type": "object", "additionalProperties": false, "required": ["horizontalColor", "verticalColor"], "properties": { "horizontalColor": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor" }, "verticalColor": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor" } } }, "thousandsSeparator": { "enum": ["", ",", " ", "_"] }, "decimalFold": { "type": "object", "additionalProperties": false, "required": ["enabled", "threshold"], "properties": { "enabled": { "type": "boolean" }, "threshold": { "type": "integer", "minimum": 1, "maximum": 16 } } }, "zoomAnchor": { "enum": ["cursor", "right"] }, "dateFormat": { "enum": ["yyyy-MM-dd", "yyyy-MM-dd HH:mm", "yyyy-MM-dd HH:mm:ss"] }, "largeNumberFormat": { "enum": ["western", "chinese", "plain"] } } };
+const pattern7 = new RegExp("^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$", "u");
+const pattern8 = new RegExp("^[A-Za-z_+-]+(?:/[A-Za-z0-9_+-]+)*$", "u");
+function validate28(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://baron.dev/kline-scene/time-series-chart-config.schema.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate28.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.locale === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "locale" }, message: "must have required property '" + "locale" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.timezone === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "timezone" }, message: "must have required property '" + "timezone" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.layout === undefined) {
+        const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "layout" }, message: "must have required property '" + "layout" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    if (data.grid === undefined) {
+        const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "grid" }, message: "must have required property '" + "grid" + "'" };
+        if (vErrors === null) {
+            vErrors = [err3];
+        }
+        else {
+            vErrors.push(err3);
+        }
+        errors++;
+    }
+    if (data.thousandsSeparator === undefined) {
+        const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "thousandsSeparator" }, message: "must have required property '" + "thousandsSeparator" + "'" };
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+    }
+    if (data.decimalFold === undefined) {
+        const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "decimalFold" }, message: "must have required property '" + "decimalFold" + "'" };
+        if (vErrors === null) {
+            vErrors = [err5];
+        }
+        else {
+            vErrors.push(err5);
+        }
+        errors++;
+    }
+    if (data.zoomAnchor === undefined) {
+        const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "zoomAnchor" }, message: "must have required property '" + "zoomAnchor" + "'" };
+        if (vErrors === null) {
+            vErrors = [err6];
+        }
+        else {
+            vErrors.push(err6);
+        }
+        errors++;
+    }
+    if (data.dateFormat === undefined) {
+        const err7 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "dateFormat" }, message: "must have required property '" + "dateFormat" + "'" };
+        if (vErrors === null) {
+            vErrors = [err7];
+        }
+        else {
+            vErrors.push(err7);
+        }
+        errors++;
+    }
+    if (data.largeNumberFormat === undefined) {
+        const err8 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "largeNumberFormat" }, message: "must have required property '" + "largeNumberFormat" + "'" };
+        if (vErrors === null) {
+            vErrors = [err8];
+        }
+        else {
+            vErrors.push(err8);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(func1.call(schema40.properties, key0))) {
+            const err9 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err9];
+            }
+            else {
+                vErrors.push(err9);
+            }
+            errors++;
+        }
+    }
+    if (data.locale !== undefined) {
+        let data0 = data.locale;
+        if (typeof data0 === "string") {
+            if (func2(data0) > 64) {
+                const err10 = { instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters" };
+                if (vErrors === null) {
+                    vErrors = [err10];
+                }
+                else {
+                    vErrors.push(err10);
+                }
+                errors++;
+            }
+            if (func2(data0) < 2) {
+                const err11 = { instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/minLength", keyword: "minLength", params: { limit: 2 }, message: "must NOT have fewer than 2 characters" };
+                if (vErrors === null) {
+                    vErrors = [err11];
+                }
+                else {
+                    vErrors.push(err11);
+                }
+                errors++;
+            }
+            if (!pattern7.test(data0)) {
+                const err12 = { instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$" }, message: "must match pattern \"" + "^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$" + "\"" };
+                if (vErrors === null) {
+                    vErrors = [err12];
+                }
+                else {
+                    vErrors.push(err12);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err13 = { instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err13];
+            }
+            else {
+                vErrors.push(err13);
+            }
+            errors++;
+        }
+    }
+    if (data.timezone !== undefined) {
+        let data1 = data.timezone;
+        if (typeof data1 === "string") {
+            if (func2(data1) > 128) {
+                const err14 = { instancePath: instancePath + "/timezone", schemaPath: "#/properties/timezone/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+            if (func2(data1) < 1) {
+                const err15 = { instancePath: instancePath + "/timezone", schemaPath: "#/properties/timezone/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                    vErrors = [err15];
+                }
+                else {
+                    vErrors.push(err15);
+                }
+                errors++;
+            }
+            if (!pattern8.test(data1)) {
+                const err16 = { instancePath: instancePath + "/timezone", schemaPath: "#/properties/timezone/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z_+-]+(?:/[A-Za-z0-9_+-]+)*$" }, message: "must match pattern \"" + "^[A-Za-z_+-]+(?:/[A-Za-z0-9_+-]+)*$" + "\"" };
+                if (vErrors === null) {
+                    vErrors = [err16];
+                }
+                else {
+                    vErrors.push(err16);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err17 = { instancePath: instancePath + "/timezone", schemaPath: "#/properties/timezone/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err17];
+            }
+            else {
+                vErrors.push(err17);
+            }
+            errors++;
+        }
+    }
+    if (data.layout !== undefined) {
+        let data2 = data.layout;
+        if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+            if (data2.backgroundColor === undefined) {
+                const err18 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/required", keyword: "required", params: { missingProperty: "backgroundColor" }, message: "must have required property '" + "backgroundColor" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err18];
+                }
+                else {
+                    vErrors.push(err18);
+                }
+                errors++;
+            }
+            if (data2.textColor === undefined) {
+                const err19 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/required", keyword: "required", params: { missingProperty: "textColor" }, message: "must have required property '" + "textColor" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err19];
+                }
+                else {
+                    vErrors.push(err19);
+                }
+                errors++;
+            }
+            if (data2.fontFamily === undefined) {
+                const err20 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/required", keyword: "required", params: { missingProperty: "fontFamily" }, message: "must have required property '" + "fontFamily" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err20];
+                }
+                else {
+                    vErrors.push(err20);
+                }
+                errors++;
+            }
+            if (data2.fontSize === undefined) {
+                const err21 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/required", keyword: "required", params: { missingProperty: "fontSize" }, message: "must have required property '" + "fontSize" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err21];
+                }
+                else {
+                    vErrors.push(err21);
+                }
+                errors++;
+            }
+            for (const key1 in data2) {
+                if (!((((key1 === "backgroundColor") || (key1 === "textColor")) || (key1 === "fontFamily")) || (key1 === "fontSize"))) {
+                    const err22 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err22];
+                    }
+                    else {
+                        vErrors.push(err22);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.backgroundColor !== undefined) {
+                let data3 = data2.backgroundColor;
+                if (typeof data3 === "string") {
+                    if (!pattern5.test(data3)) {
+                        const err23 = { instancePath: instancePath + "/layout/backgroundColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/pattern", keyword: "pattern", params: { pattern: "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" }, message: "must match pattern \"" + "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" + "\"" };
+                        if (vErrors === null) {
+                            vErrors = [err23];
+                        }
+                        else {
+                            vErrors.push(err23);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err24 = { instancePath: instancePath + "/layout/backgroundColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err24];
+                    }
+                    else {
+                        vErrors.push(err24);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.textColor !== undefined) {
+                let data4 = data2.textColor;
+                if (typeof data4 === "string") {
+                    if (!pattern5.test(data4)) {
+                        const err25 = { instancePath: instancePath + "/layout/textColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/pattern", keyword: "pattern", params: { pattern: "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" }, message: "must match pattern \"" + "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" + "\"" };
+                        if (vErrors === null) {
+                            vErrors = [err25];
+                        }
+                        else {
+                            vErrors.push(err25);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err26 = { instancePath: instancePath + "/layout/textColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err26];
+                    }
+                    else {
+                        vErrors.push(err26);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.fontFamily !== undefined) {
+                let data5 = data2.fontFamily;
+                if (typeof data5 === "string") {
+                    if (func2(data5) > 128) {
+                        const err27 = { instancePath: instancePath + "/layout/fontFamily", schemaPath: "#/properties/layout/properties/fontFamily/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" };
+                        if (vErrors === null) {
+                            vErrors = [err27];
+                        }
+                        else {
+                            vErrors.push(err27);
+                        }
+                        errors++;
+                    }
+                    if (func2(data5) < 1) {
+                        const err28 = { instancePath: instancePath + "/layout/fontFamily", schemaPath: "#/properties/layout/properties/fontFamily/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                        if (vErrors === null) {
+                            vErrors = [err28];
+                        }
+                        else {
+                            vErrors.push(err28);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err29 = { instancePath: instancePath + "/layout/fontFamily", schemaPath: "#/properties/layout/properties/fontFamily/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err29];
+                    }
+                    else {
+                        vErrors.push(err29);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.fontSize !== undefined) {
+                let data6 = data2.fontSize;
+                if ((typeof data6 == "number") && (isFinite(data6))) {
+                    if (data6 > 32 || isNaN(data6)) {
+                        const err30 = { instancePath: instancePath + "/layout/fontSize", schemaPath: "#/properties/layout/properties/fontSize/maximum", keyword: "maximum", params: { comparison: "<=", limit: 32 }, message: "must be <= 32" };
+                        if (vErrors === null) {
+                            vErrors = [err30];
+                        }
+                        else {
+                            vErrors.push(err30);
+                        }
+                        errors++;
+                    }
+                    if (data6 < 8 || isNaN(data6)) {
+                        const err31 = { instancePath: instancePath + "/layout/fontSize", schemaPath: "#/properties/layout/properties/fontSize/minimum", keyword: "minimum", params: { comparison: ">=", limit: 8 }, message: "must be >= 8" };
+                        if (vErrors === null) {
+                            vErrors = [err31];
+                        }
+                        else {
+                            vErrors.push(err31);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err32 = { instancePath: instancePath + "/layout/fontSize", schemaPath: "#/properties/layout/properties/fontSize/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                        vErrors = [err32];
+                    }
+                    else {
+                        vErrors.push(err32);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err33 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err33];
+            }
+            else {
+                vErrors.push(err33);
+            }
+            errors++;
+        }
+    }
+    if (data.grid !== undefined) {
+        let data7 = data.grid;
+        if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+            if (data7.horizontalColor === undefined) {
+                const err34 = { instancePath: instancePath + "/grid", schemaPath: "#/properties/grid/required", keyword: "required", params: { missingProperty: "horizontalColor" }, message: "must have required property '" + "horizontalColor" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err34];
+                }
+                else {
+                    vErrors.push(err34);
+                }
+                errors++;
+            }
+            if (data7.verticalColor === undefined) {
+                const err35 = { instancePath: instancePath + "/grid", schemaPath: "#/properties/grid/required", keyword: "required", params: { missingProperty: "verticalColor" }, message: "must have required property '" + "verticalColor" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err35];
+                }
+                else {
+                    vErrors.push(err35);
+                }
+                errors++;
+            }
+            for (const key2 in data7) {
+                if (!((key2 === "horizontalColor") || (key2 === "verticalColor"))) {
+                    const err36 = { instancePath: instancePath + "/grid", schemaPath: "#/properties/grid/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err36];
+                    }
+                    else {
+                        vErrors.push(err36);
+                    }
+                    errors++;
+                }
+            }
+            if (data7.horizontalColor !== undefined) {
+                let data8 = data7.horizontalColor;
+                if (typeof data8 === "string") {
+                    if (!pattern5.test(data8)) {
+                        const err37 = { instancePath: instancePath + "/grid/horizontalColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/pattern", keyword: "pattern", params: { pattern: "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" }, message: "must match pattern \"" + "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" + "\"" };
+                        if (vErrors === null) {
+                            vErrors = [err37];
+                        }
+                        else {
+                            vErrors.push(err37);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err38 = { instancePath: instancePath + "/grid/horizontalColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err38];
+                    }
+                    else {
+                        vErrors.push(err38);
+                    }
+                    errors++;
+                }
+            }
+            if (data7.verticalColor !== undefined) {
+                let data9 = data7.verticalColor;
+                if (typeof data9 === "string") {
+                    if (!pattern5.test(data9)) {
+                        const err39 = { instancePath: instancePath + "/grid/verticalColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/pattern", keyword: "pattern", params: { pattern: "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" }, message: "must match pattern \"" + "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" + "\"" };
+                        if (vErrors === null) {
+                            vErrors = [err39];
+                        }
+                        else {
+                            vErrors.push(err39);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err40 = { instancePath: instancePath + "/grid/verticalColor", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err40];
+                    }
+                    else {
+                        vErrors.push(err40);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err41 = { instancePath: instancePath + "/grid", schemaPath: "#/properties/grid/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err41];
+            }
+            else {
+                vErrors.push(err41);
+            }
+            errors++;
+        }
+    }
+    if (data.thousandsSeparator !== undefined) {
+        let data10 = data.thousandsSeparator;
+        if (!((((data10 === "") || (data10 === ",")) || (data10 === " ")) || (data10 === "_"))) {
+            const err42 = { instancePath: instancePath + "/thousandsSeparator", schemaPath: "#/properties/thousandsSeparator/enum", keyword: "enum", params: { allowedValues: schema40.properties.thousandsSeparator.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+                vErrors = [err42];
+            }
+            else {
+                vErrors.push(err42);
+            }
+            errors++;
+        }
+    }
+    if (data.decimalFold !== undefined) {
+        let data11 = data.decimalFold;
+        if (data11 && typeof data11 == "object" && !Array.isArray(data11)) {
+            if (data11.enabled === undefined) {
+                const err43 = { instancePath: instancePath + "/decimalFold", schemaPath: "#/properties/decimalFold/required", keyword: "required", params: { missingProperty: "enabled" }, message: "must have required property '" + "enabled" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err43];
+                }
+                else {
+                    vErrors.push(err43);
+                }
+                errors++;
+            }
+            if (data11.threshold === undefined) {
+                const err44 = { instancePath: instancePath + "/decimalFold", schemaPath: "#/properties/decimalFold/required", keyword: "required", params: { missingProperty: "threshold" }, message: "must have required property '" + "threshold" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err44];
+                }
+                else {
+                    vErrors.push(err44);
+                }
+                errors++;
+            }
+            for (const key3 in data11) {
+                if (!((key3 === "enabled") || (key3 === "threshold"))) {
+                    const err45 = { instancePath: instancePath + "/decimalFold", schemaPath: "#/properties/decimalFold/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err45];
+                    }
+                    else {
+                        vErrors.push(err45);
+                    }
+                    errors++;
+                }
+            }
+            if (data11.enabled !== undefined) {
+                if (typeof data11.enabled !== "boolean") {
+                    const err46 = { instancePath: instancePath + "/decimalFold/enabled", schemaPath: "#/properties/decimalFold/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                    if (vErrors === null) {
+                        vErrors = [err46];
+                    }
+                    else {
+                        vErrors.push(err46);
+                    }
+                    errors++;
+                }
+            }
+            if (data11.threshold !== undefined) {
+                let data13 = data11.threshold;
+                if (!(((typeof data13 == "number") && (!(data13 % 1) && !isNaN(data13))) && (isFinite(data13)))) {
+                    const err47 = { instancePath: instancePath + "/decimalFold/threshold", schemaPath: "#/properties/decimalFold/properties/threshold/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                    if (vErrors === null) {
+                        vErrors = [err47];
+                    }
+                    else {
+                        vErrors.push(err47);
+                    }
+                    errors++;
+                }
+                if ((typeof data13 == "number") && (isFinite(data13))) {
+                    if (data13 > 16 || isNaN(data13)) {
+                        const err48 = { instancePath: instancePath + "/decimalFold/threshold", schemaPath: "#/properties/decimalFold/properties/threshold/maximum", keyword: "maximum", params: { comparison: "<=", limit: 16 }, message: "must be <= 16" };
+                        if (vErrors === null) {
+                            vErrors = [err48];
+                        }
+                        else {
+                            vErrors.push(err48);
+                        }
+                        errors++;
+                    }
+                    if (data13 < 1 || isNaN(data13)) {
+                        const err49 = { instancePath: instancePath + "/decimalFold/threshold", schemaPath: "#/properties/decimalFold/properties/threshold/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                        if (vErrors === null) {
+                            vErrors = [err49];
+                        }
+                        else {
+                            vErrors.push(err49);
+                        }
+                        errors++;
+                    }
+                }
+            }
+        }
+        else {
+            const err50 = { instancePath: instancePath + "/decimalFold", schemaPath: "#/properties/decimalFold/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err50];
+            }
+            else {
+                vErrors.push(err50);
+            }
+            errors++;
+        }
+    }
+    if (data.zoomAnchor !== undefined) {
+        let data14 = data.zoomAnchor;
+        if (!((data14 === "cursor") || (data14 === "right"))) {
+            const err51 = { instancePath: instancePath + "/zoomAnchor", schemaPath: "#/properties/zoomAnchor/enum", keyword: "enum", params: { allowedValues: schema40.properties.zoomAnchor.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+                vErrors = [err51];
+            }
+            else {
+                vErrors.push(err51);
+            }
+            errors++;
+        }
+    }
+    if (data.dateFormat !== undefined) {
+        let data15 = data.dateFormat;
+        if (!(((data15 === "yyyy-MM-dd") || (data15 === "yyyy-MM-dd HH:mm")) || (data15 === "yyyy-MM-dd HH:mm:ss"))) {
+            const err52 = { instancePath: instancePath + "/dateFormat", schemaPath: "#/properties/dateFormat/enum", keyword: "enum", params: { allowedValues: schema40.properties.dateFormat.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+                vErrors = [err52];
+            }
+            else {
+                vErrors.push(err52);
+            }
+            errors++;
+        }
+    }
+    if (data.largeNumberFormat !== undefined) {
+        let data16 = data.largeNumberFormat;
+        if (!(((data16 === "western") || (data16 === "chinese")) || (data16 === "plain"))) {
+            const err53 = { instancePath: instancePath + "/largeNumberFormat", schemaPath: "#/properties/largeNumberFormat/enum", keyword: "enum", params: { allowedValues: schema40.properties.largeNumberFormat.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+                vErrors = [err53];
+            }
+            else {
+                vErrors.push(err53);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err54 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err54];
+    }
+    else {
+        vErrors.push(err54);
+    }
+    errors++;
+} validate28.errors = vErrors; return errors === 0; }
+validate28.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+const schema46 = { "type": "object", "additionalProperties": false, "required": ["width", "height", "deviceScaleFactor", "background", "fontFamily", "timeoutMs"], "properties": { "width": { "type": "integer", "minimum": 320, "maximum": 8192 }, "height": { "type": "integer", "minimum": 240, "maximum": 8192 }, "deviceScaleFactor": { "type": "number", "minimum": 0.5, "maximum": 4 }, "background": { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor" }, "fontFamily": { "const": "Baron Sans" }, "timeoutMs": { "type": "integer", "minimum": 100, "maximum": 120000 } } };
+function validate30(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate30.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.width === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "width" }, message: "must have required property '" + "width" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.height === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "height" }, message: "must have required property '" + "height" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.deviceScaleFactor === undefined) {
+        const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "deviceScaleFactor" }, message: "must have required property '" + "deviceScaleFactor" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    if (data.background === undefined) {
+        const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "background" }, message: "must have required property '" + "background" + "'" };
+        if (vErrors === null) {
+            vErrors = [err3];
+        }
+        else {
+            vErrors.push(err3);
+        }
+        errors++;
+    }
+    if (data.fontFamily === undefined) {
+        const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "fontFamily" }, message: "must have required property '" + "fontFamily" + "'" };
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+    }
+    if (data.timeoutMs === undefined) {
+        const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "timeoutMs" }, message: "must have required property '" + "timeoutMs" + "'" };
+        if (vErrors === null) {
+            vErrors = [err5];
+        }
+        else {
+            vErrors.push(err5);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!((((((key0 === "width") || (key0 === "height")) || (key0 === "deviceScaleFactor")) || (key0 === "background")) || (key0 === "fontFamily")) || (key0 === "timeoutMs"))) {
+            const err6 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err6];
+            }
+            else {
+                vErrors.push(err6);
+            }
+            errors++;
+        }
+    }
+    if (data.width !== undefined) {
+        let data0 = data.width;
+        if (!(((typeof data0 == "number") && (!(data0 % 1) && !isNaN(data0))) && (isFinite(data0)))) {
+            const err7 = { instancePath: instancePath + "/width", schemaPath: "#/properties/width/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+                vErrors = [err7];
+            }
+            else {
+                vErrors.push(err7);
+            }
+            errors++;
+        }
+        if ((typeof data0 == "number") && (isFinite(data0))) {
+            if (data0 > 8192 || isNaN(data0)) {
+                const err8 = { instancePath: instancePath + "/width", schemaPath: "#/properties/width/maximum", keyword: "maximum", params: { comparison: "<=", limit: 8192 }, message: "must be <= 8192" };
+                if (vErrors === null) {
+                    vErrors = [err8];
+                }
+                else {
+                    vErrors.push(err8);
+                }
+                errors++;
+            }
+            if (data0 < 320 || isNaN(data0)) {
+                const err9 = { instancePath: instancePath + "/width", schemaPath: "#/properties/width/minimum", keyword: "minimum", params: { comparison: ">=", limit: 320 }, message: "must be >= 320" };
+                if (vErrors === null) {
+                    vErrors = [err9];
+                }
+                else {
+                    vErrors.push(err9);
+                }
+                errors++;
+            }
+        }
+    }
+    if (data.height !== undefined) {
+        let data1 = data.height;
+        if (!(((typeof data1 == "number") && (!(data1 % 1) && !isNaN(data1))) && (isFinite(data1)))) {
+            const err10 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+                vErrors = [err10];
+            }
+            else {
+                vErrors.push(err10);
+            }
+            errors++;
+        }
+        if ((typeof data1 == "number") && (isFinite(data1))) {
+            if (data1 > 8192 || isNaN(data1)) {
+                const err11 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/maximum", keyword: "maximum", params: { comparison: "<=", limit: 8192 }, message: "must be <= 8192" };
+                if (vErrors === null) {
+                    vErrors = [err11];
+                }
+                else {
+                    vErrors.push(err11);
+                }
+                errors++;
+            }
+            if (data1 < 240 || isNaN(data1)) {
+                const err12 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/minimum", keyword: "minimum", params: { comparison: ">=", limit: 240 }, message: "must be >= 240" };
+                if (vErrors === null) {
+                    vErrors = [err12];
+                }
+                else {
+                    vErrors.push(err12);
+                }
+                errors++;
+            }
+        }
+    }
+    if (data.deviceScaleFactor !== undefined) {
+        let data2 = data.deviceScaleFactor;
+        if ((typeof data2 == "number") && (isFinite(data2))) {
+            if (data2 > 4 || isNaN(data2)) {
+                const err13 = { instancePath: instancePath + "/deviceScaleFactor", schemaPath: "#/properties/deviceScaleFactor/maximum", keyword: "maximum", params: { comparison: "<=", limit: 4 }, message: "must be <= 4" };
+                if (vErrors === null) {
+                    vErrors = [err13];
+                }
+                else {
+                    vErrors.push(err13);
+                }
+                errors++;
+            }
+            if (data2 < 0.5 || isNaN(data2)) {
+                const err14 = { instancePath: instancePath + "/deviceScaleFactor", schemaPath: "#/properties/deviceScaleFactor/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0.5 }, message: "must be >= 0.5" };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err15 = { instancePath: instancePath + "/deviceScaleFactor", schemaPath: "#/properties/deviceScaleFactor/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err15];
+            }
+            else {
+                vErrors.push(err15);
+            }
+            errors++;
+        }
+    }
+    if (data.background !== undefined) {
+        let data3 = data.background;
+        if (typeof data3 === "string") {
+            if (!pattern5.test(data3)) {
+                const err16 = { instancePath: instancePath + "/background", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/pattern", keyword: "pattern", params: { pattern: "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" }, message: "must match pattern \"" + "^rgba\\(\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*[0-9]{1,3}\\s*,\\s*(?:0(?:\\.[0-9]+)?|1(?:\\.0+)?)\\s*\\)$" + "\"" };
+                if (vErrors === null) {
+                    vErrors = [err16];
+                }
+                else {
+                    vErrors.push(err16);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err17 = { instancePath: instancePath + "/background", schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err17];
+            }
+            else {
+                vErrors.push(err17);
+            }
+            errors++;
+        }
+    }
+    if (data.fontFamily !== undefined) {
+        if ("Baron Sans" !== data.fontFamily) {
+            const err18 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/const", keyword: "const", params: { allowedValue: "Baron Sans" }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err18];
+            }
+            else {
+                vErrors.push(err18);
+            }
+            errors++;
+        }
+    }
+    if (data.timeoutMs !== undefined) {
+        let data5 = data.timeoutMs;
+        if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
+            const err19 = { instancePath: instancePath + "/timeoutMs", schemaPath: "#/properties/timeoutMs/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+                vErrors = [err19];
+            }
+            else {
+                vErrors.push(err19);
+            }
+            errors++;
+        }
+        if ((typeof data5 == "number") && (isFinite(data5))) {
+            if (data5 > 120000 || isNaN(data5)) {
+                const err20 = { instancePath: instancePath + "/timeoutMs", schemaPath: "#/properties/timeoutMs/maximum", keyword: "maximum", params: { comparison: "<=", limit: 120000 }, message: "must be <= 120000" };
+                if (vErrors === null) {
+                    vErrors = [err20];
+                }
+                else {
+                    vErrors.push(err20);
+                }
+                errors++;
+            }
+            if (data5 < 100 || isNaN(data5)) {
+                const err21 = { instancePath: instancePath + "/timeoutMs", schemaPath: "#/properties/timeoutMs/minimum", keyword: "minimum", params: { comparison: ">=", limit: 100 }, message: "must be >= 100" };
+                if (vErrors === null) {
+                    vErrors = [err21];
+                }
+                else {
+                    vErrors.push(err21);
+                }
+                errors++;
+            }
+        }
+    }
+}
+else {
+    const err22 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err22];
+    }
+    else {
+        vErrors.push(err22);
+    }
+    errors++;
+} validate30.errors = vErrors; return errors === 0; }
+validate30.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+const schema48 = { "type": "object", "maxProperties": 64, "propertyNames": { "type": "string", "minLength": 1, "maxLength": 128 }, "additionalProperties": { "oneOf": [{ "type": "null" }, { "type": "boolean" }, { "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber" }, { "type": "string" }] } };
+function validate32(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate32.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (Object.keys(data).length > 64) {
+        const err0 = { instancePath, schemaPath: "#/maxProperties", keyword: "maxProperties", params: { limit: 64 }, message: "must NOT have more than 64 properties" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        const _errs1 = errors;
+        if (typeof key0 === "string") {
+            if (func2(key0) > 128) {
+                const err1 = { instancePath, schemaPath: "#/propertyNames/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters", propertyName: key0 };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+            if (func2(key0) < 1) {
+                const err2 = { instancePath, schemaPath: "#/propertyNames/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters", propertyName: key0 };
+                if (vErrors === null) {
+                    vErrors = [err2];
+                }
+                else {
+                    vErrors.push(err2);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err3 = { instancePath, schemaPath: "#/propertyNames/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key0 };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+        var valid0 = _errs1 === errors;
+        if (!valid0) {
+            const err4 = { instancePath, schemaPath: "#/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+            if (vErrors === null) {
+                vErrors = [err4];
+            }
+            else {
+                vErrors.push(err4);
+            }
+            errors++;
+        }
+    }
+    for (const key1 in data) {
+        let data0 = data[key1];
+        const _errs5 = errors;
+        let valid2 = false;
+        let passing0 = null;
+        const _errs6 = errors;
+        if (data0 !== null) {
+            const err5 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/additionalProperties/oneOf/0/type", keyword: "type", params: { type: "null" }, message: "must be null" };
+            if (vErrors === null) {
+                vErrors = [err5];
+            }
+            else {
+                vErrors.push(err5);
+            }
+            errors++;
+        }
+        var _valid0 = _errs6 === errors;
+        if (_valid0) {
+            valid2 = true;
+            passing0 = 0;
+        }
+        const _errs8 = errors;
+        if (typeof data0 !== "boolean") {
+            const err6 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/additionalProperties/oneOf/1/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+            if (vErrors === null) {
+                vErrors = [err6];
+            }
+            else {
+                vErrors.push(err6);
+            }
+            errors++;
+        }
+        var _valid0 = _errs8 === errors;
+        if (_valid0 && valid2) {
+            valid2 = false;
+            passing0 = [passing0, 1];
+        }
+        else {
+            if (_valid0) {
+                valid2 = true;
+                passing0 = 1;
+            }
+            const _errs10 = errors;
+            if ((typeof data0 == "number") && (isFinite(data0))) {
+                if (data0 > 1.7976931348623157e+308 || isNaN(data0)) {
+                    const err7 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1.7976931348623157e+308 }, message: "must be <= 1.7976931348623157e+308" };
+                    if (vErrors === null) {
+                        vErrors = [err7];
+                    }
+                    else {
+                        vErrors.push(err7);
+                    }
+                    errors++;
+                }
+                if (data0 < -1.7976931348623157e+308 || isNaN(data0)) {
+                    const err8 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber/minimum", keyword: "minimum", params: { comparison: ">=", limit: -1.7976931348623157e+308 }, message: "must be >= -1.7976931348623157e+308" };
+                    if (vErrors === null) {
+                        vErrors = [err8];
+                    }
+                    else {
+                        vErrors.push(err8);
+                    }
+                    errors++;
+                }
+            }
+            else {
+                const err9 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err9];
+                }
+                else {
+                    vErrors.push(err9);
+                }
+                errors++;
+            }
+            var _valid0 = _errs10 === errors;
+            if (_valid0 && valid2) {
+                valid2 = false;
+                passing0 = [passing0, 2];
+            }
+            else {
+                if (_valid0) {
+                    valid2 = true;
+                    passing0 = 2;
+                }
+                const _errs13 = errors;
+                if (typeof data0 !== "string") {
+                    const err10 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/additionalProperties/oneOf/3/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err10];
+                    }
+                    else {
+                        vErrors.push(err10);
+                    }
+                    errors++;
+                }
+                var _valid0 = _errs13 === errors;
+                if (_valid0 && valid2) {
+                    valid2 = false;
+                    passing0 = [passing0, 3];
+                }
+                else {
+                    if (_valid0) {
+                        valid2 = true;
+                        passing0 = 3;
+                    }
+                }
+            }
+        }
+        if (!valid2) {
+            const err11 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/additionalProperties/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+            if (vErrors === null) {
+                vErrors = [err11];
+            }
+            else {
+                vErrors.push(err11);
+            }
+            errors++;
+        }
+        else {
+            errors = _errs5;
+            if (vErrors !== null) {
+                if (_errs5) {
+                    vErrors.length = _errs5;
+                }
+                else {
+                    vErrors = null;
+                }
+            }
+        }
+    }
+}
+else {
+    const err12 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err12];
+    }
+    else {
+        vErrors.push(err12);
+    }
+    errors++;
+} validate32.errors = vErrors; return errors === 0; }
+validate32.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://baron.dev/kline-scene/time-series-scene.schema.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate20.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.schema === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "schema" }, message: "must have required property '" + "schema" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.version === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property '" + "version" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.runtime === undefined) {
+        const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "runtime" }, message: "must have required property '" + "runtime" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    if (data.period === undefined) {
+        const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "period" }, message: "must have required property '" + "period" + "'" };
+        if (vErrors === null) {
+            vErrors = [err3];
+        }
+        else {
+            vErrors.push(err3);
+        }
+        errors++;
+    }
+    if (data.series === undefined) {
+        const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "series" }, message: "must have required property '" + "series" + "'" };
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+    }
+    if (data.data === undefined) {
+        const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "data" }, message: "must have required property '" + "data" + "'" };
+        if (vErrors === null) {
+            vErrors = [err5];
+        }
+        else {
+            vErrors.push(err5);
+        }
+        errors++;
+    }
+    if (data.chart === undefined) {
+        const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "chart" }, message: "must have required property '" + "chart" + "'" };
+        if (vErrors === null) {
+            vErrors = [err6];
+        }
+        else {
+            vErrors.push(err6);
+        }
+        errors++;
+    }
+    if (data.viewport === undefined) {
+        const err7 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "viewport" }, message: "must have required property '" + "viewport" + "'" };
+        if (vErrors === null) {
+            vErrors = [err7];
+        }
+        else {
+            vErrors.push(err7);
+        }
+        errors++;
+    }
+    if (data.render === undefined) {
+        const err8 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "render" }, message: "must have required property '" + "render" + "'" };
+        if (vErrors === null) {
+            vErrors = [err8];
+        }
+        else {
+            vErrors.push(err8);
+        }
+        errors++;
+    }
+    if (data.metadata === undefined) {
+        const err9 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "metadata" }, message: "must have required property '" + "metadata" + "'" };
+        if (vErrors === null) {
+            vErrors = [err9];
+        }
+        else {
+            vErrors.push(err9);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(func1.call(schema31.properties, key0))) {
+            const err10 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err10];
+            }
+            else {
+                vErrors.push(err10);
+            }
+            errors++;
+        }
+    }
+    if (data.schema !== undefined) {
+        if ("@baron1996/time-series-scene" !== data.schema) {
+            const err11 = { instancePath: instancePath + "/schema", schemaPath: "#/properties/schema/const", keyword: "const", params: { allowedValue: "@baron1996/time-series-scene" }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err11];
+            }
+            else {
+                vErrors.push(err11);
+            }
+            errors++;
+        }
+    }
+    if (data.version !== undefined) {
+        if (1 !== data.version) {
+            const err12 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/const", keyword: "const", params: { allowedValue: 1 }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err12];
+            }
+            else {
+                vErrors.push(err12);
+            }
+            errors++;
+        }
+    }
+    if (data.runtime !== undefined) {
+        let data2 = data.runtime;
+        if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+            if (data2.engine === undefined) {
+                const err13 = { instancePath: instancePath + "/runtime", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/required", keyword: "required", params: { missingProperty: "engine" }, message: "must have required property '" + "engine" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err13];
+                }
+                else {
+                    vErrors.push(err13);
+                }
+                errors++;
+            }
+            if (data2.engineVersion === undefined) {
+                const err14 = { instancePath: instancePath + "/runtime", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/required", keyword: "required", params: { missingProperty: "engineVersion" }, message: "must have required property '" + "engineVersion" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+            if (data2.runtimeVersion === undefined) {
+                const err15 = { instancePath: instancePath + "/runtime", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/required", keyword: "required", params: { missingProperty: "runtimeVersion" }, message: "must have required property '" + "runtimeVersion" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err15];
+                }
+                else {
+                    vErrors.push(err15);
+                }
+                errors++;
+            }
+            for (const key1 in data2) {
+                if (!(((key1 === "engine") || (key1 === "engineVersion")) || (key1 === "runtimeVersion"))) {
+                    const err16 = { instancePath: instancePath + "/runtime", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err16];
+                    }
+                    else {
+                        vErrors.push(err16);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.engine !== undefined) {
+                if ("klinecharts" !== data2.engine) {
+                    const err17 = { instancePath: instancePath + "/runtime/engine", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/properties/engine/const", keyword: "const", params: { allowedValue: "klinecharts" }, message: "must be equal to constant" };
+                    if (vErrors === null) {
+                        vErrors = [err17];
+                    }
+                    else {
+                        vErrors.push(err17);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.engineVersion !== undefined) {
+                if ("10.0.0" !== data2.engineVersion) {
+                    const err18 = { instancePath: instancePath + "/runtime/engineVersion", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/properties/engineVersion/const", keyword: "const", params: { allowedValue: "10.0.0" }, message: "must be equal to constant" };
+                    if (vErrors === null) {
+                        vErrors = [err18];
+                    }
+                    else {
+                        vErrors.push(err18);
+                    }
+                    errors++;
+                }
+            }
+            if (data2.runtimeVersion !== undefined) {
+                if ("0.1.0" !== data2.runtimeVersion) {
+                    const err19 = { instancePath: instancePath + "/runtime/runtimeVersion", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/properties/runtimeVersion/const", keyword: "const", params: { allowedValue: "0.1.0" }, message: "must be equal to constant" };
+                    if (vErrors === null) {
+                        vErrors = [err19];
+                    }
+                    else {
+                        vErrors.push(err19);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err20 = { instancePath: instancePath + "/runtime", schemaPath: "https://baron.dev/kline-scene/time-series-runtime.schema.json/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err20];
+            }
+            else {
+                vErrors.push(err20);
+            }
+            errors++;
+        }
+    }
+    if (data.period !== undefined) {
+        let data6 = data.period;
+        if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+            if (data6.span === undefined) {
+                const err21 = { instancePath: instancePath + "/period", schemaPath: "#/$defs/timeSeriesPeriod/required", keyword: "required", params: { missingProperty: "span" }, message: "must have required property '" + "span" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err21];
+                }
+                else {
+                    vErrors.push(err21);
+                }
+                errors++;
+            }
+            if (data6.type === undefined) {
+                const err22 = { instancePath: instancePath + "/period", schemaPath: "#/$defs/timeSeriesPeriod/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property '" + "type" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err22];
+                }
+                else {
+                    vErrors.push(err22);
+                }
+                errors++;
+            }
+            for (const key2 in data6) {
+                if (!((key2 === "span") || (key2 === "type"))) {
+                    const err23 = { instancePath: instancePath + "/period", schemaPath: "#/$defs/timeSeriesPeriod/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err23];
+                    }
+                    else {
+                        vErrors.push(err23);
+                    }
+                    errors++;
+                }
+            }
+            if (data6.span !== undefined) {
+                let data7 = data6.span;
+                if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
+                    const err24 = { instancePath: instancePath + "/period/span", schemaPath: "#/$defs/timeSeriesPeriod/properties/span/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                    if (vErrors === null) {
+                        vErrors = [err24];
+                    }
+                    else {
+                        vErrors.push(err24);
+                    }
+                    errors++;
+                }
+                if ((typeof data7 == "number") && (isFinite(data7))) {
+                    if (data7 > 100000 || isNaN(data7)) {
+                        const err25 = { instancePath: instancePath + "/period/span", schemaPath: "#/$defs/timeSeriesPeriod/properties/span/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100000 }, message: "must be <= 100000" };
+                        if (vErrors === null) {
+                            vErrors = [err25];
+                        }
+                        else {
+                            vErrors.push(err25);
+                        }
+                        errors++;
+                    }
+                    if (data7 < 1 || isNaN(data7)) {
+                        const err26 = { instancePath: instancePath + "/period/span", schemaPath: "#/$defs/timeSeriesPeriod/properties/span/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                        if (vErrors === null) {
+                            vErrors = [err26];
+                        }
+                        else {
+                            vErrors.push(err26);
+                        }
+                        errors++;
+                    }
+                }
+            }
+            if (data6.type !== undefined) {
+                let data8 = data6.type;
+                if (!(((((((data8 === "second") || (data8 === "minute")) || (data8 === "hour")) || (data8 === "day")) || (data8 === "week")) || (data8 === "month")) || (data8 === "year"))) {
+                    const err27 = { instancePath: instancePath + "/period/type", schemaPath: "#/$defs/timeSeriesPeriod/properties/type/enum", keyword: "enum", params: { allowedValues: schema33.properties.type.enum }, message: "must be equal to one of the allowed values" };
+                    if (vErrors === null) {
+                        vErrors = [err27];
+                    }
+                    else {
+                        vErrors.push(err27);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err28 = { instancePath: instancePath + "/period", schemaPath: "#/$defs/timeSeriesPeriod/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err28];
+            }
+            else {
+                vErrors.push(err28);
+            }
+            errors++;
+        }
+    }
+    if (data.series !== undefined) {
+        let data9 = data.series;
+        if (Array.isArray(data9)) {
+            if (data9.length > 64) {
+                const err29 = { instancePath: instancePath + "/series", schemaPath: "#/properties/series/maxItems", keyword: "maxItems", params: { limit: 64 }, message: "must NOT have more than 64 items" };
+                if (vErrors === null) {
+                    vErrors = [err29];
+                }
+                else {
+                    vErrors.push(err29);
+                }
+                errors++;
+            }
+            if (data9.length < 1) {
+                const err30 = { instancePath: instancePath + "/series", schemaPath: "#/properties/series/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+                if (vErrors === null) {
+                    vErrors = [err30];
+                }
+                else {
+                    vErrors.push(err30);
+                }
+                errors++;
+            }
+            const len0 = data9.length;
+            for (let i0 = 0; i0 < len0; i0++) {
+                if (!(validate21(data9[i0], { instancePath: instancePath + "/series/" + i0, parentData: data9, parentDataProperty: i0, rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
+                    errors = vErrors.length;
+                }
+            }
+        }
+        else {
+            const err31 = { instancePath: instancePath + "/series", schemaPath: "#/properties/series/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err31];
+            }
+            else {
+                vErrors.push(err31);
+            }
+            errors++;
+        }
+    }
+    if (data.data !== undefined) {
+        let data11 = data.data;
+        if (Array.isArray(data11)) {
+            if (data11.length > 1000000) {
+                const err32 = { instancePath: instancePath + "/data", schemaPath: "#/properties/data/maxItems", keyword: "maxItems", params: { limit: 1000000 }, message: "must NOT have more than 1000000 items" };
+                if (vErrors === null) {
+                    vErrors = [err32];
+                }
+                else {
+                    vErrors.push(err32);
+                }
+                errors++;
+            }
+            if (data11.length < 1) {
+                const err33 = { instancePath: instancePath + "/data", schemaPath: "#/properties/data/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+                if (vErrors === null) {
+                    vErrors = [err33];
+                }
+                else {
+                    vErrors.push(err33);
+                }
+                errors++;
+            }
+            const len1 = data11.length;
+            for (let i1 = 0; i1 < len1; i1++) {
+                if (!(validate26(data11[i1], { instancePath: instancePath + "/data/" + i1, parentData: data11, parentDataProperty: i1, rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate26.errors : vErrors.concat(validate26.errors);
+                    errors = vErrors.length;
+                }
+            }
+        }
+        else {
+            const err34 = { instancePath: instancePath + "/data", schemaPath: "#/properties/data/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err34];
+            }
+            else {
+                vErrors.push(err34);
+            }
+            errors++;
+        }
+    }
+    if (data.chart !== undefined) {
+        if (!(validate28(data.chart, { instancePath: instancePath + "/chart", parentData: data, parentDataProperty: "chart", rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate28.errors : vErrors.concat(validate28.errors);
+            errors = vErrors.length;
+        }
+    }
+    if (data.viewport !== undefined) {
+        let data14 = data.viewport;
+        if (data14 && typeof data14 == "object" && !Array.isArray(data14)) {
+            if (data14.barSpace === undefined) {
+                const err35 = { instancePath: instancePath + "/viewport", schemaPath: "#/$defs/timeSeriesViewport/required", keyword: "required", params: { missingProperty: "barSpace" }, message: "must have required property '" + "barSpace" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err35];
+                }
+                else {
+                    vErrors.push(err35);
+                }
+                errors++;
+            }
+            if (data14.rightOffsetDistance === undefined) {
+                const err36 = { instancePath: instancePath + "/viewport", schemaPath: "#/$defs/timeSeriesViewport/required", keyword: "required", params: { missingProperty: "rightOffsetDistance" }, message: "must have required property '" + "rightOffsetDistance" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err36];
+                }
+                else {
+                    vErrors.push(err36);
+                }
+                errors++;
+            }
+            if (data14.anchorTimestamp === undefined) {
+                const err37 = { instancePath: instancePath + "/viewport", schemaPath: "#/$defs/timeSeriesViewport/required", keyword: "required", params: { missingProperty: "anchorTimestamp" }, message: "must have required property '" + "anchorTimestamp" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err37];
+                }
+                else {
+                    vErrors.push(err37);
+                }
+                errors++;
+            }
+            for (const key3 in data14) {
+                if (!(((key3 === "barSpace") || (key3 === "rightOffsetDistance")) || (key3 === "anchorTimestamp"))) {
+                    const err38 = { instancePath: instancePath + "/viewport", schemaPath: "#/$defs/timeSeriesViewport/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err38];
+                    }
+                    else {
+                        vErrors.push(err38);
+                    }
+                    errors++;
+                }
+            }
+            if (data14.barSpace !== undefined) {
+                let data15 = data14.barSpace;
+                if ((typeof data15 == "number") && (isFinite(data15))) {
+                    if (data15 > 100 || isNaN(data15)) {
+                        const err39 = { instancePath: instancePath + "/viewport/barSpace", schemaPath: "#/$defs/timeSeriesViewport/properties/barSpace/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
+                        if (vErrors === null) {
+                            vErrors = [err39];
+                        }
+                        else {
+                            vErrors.push(err39);
+                        }
+                        errors++;
+                    }
+                    if (data15 < 1 || isNaN(data15)) {
+                        const err40 = { instancePath: instancePath + "/viewport/barSpace", schemaPath: "#/$defs/timeSeriesViewport/properties/barSpace/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                        if (vErrors === null) {
+                            vErrors = [err40];
+                        }
+                        else {
+                            vErrors.push(err40);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err41 = { instancePath: instancePath + "/viewport/barSpace", schemaPath: "#/$defs/timeSeriesViewport/properties/barSpace/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                        vErrors = [err41];
+                    }
+                    else {
+                        vErrors.push(err41);
+                    }
+                    errors++;
+                }
+            }
+            if (data14.rightOffsetDistance !== undefined) {
+                let data16 = data14.rightOffsetDistance;
+                if ((typeof data16 == "number") && (isFinite(data16))) {
+                    if (data16 > 10000 || isNaN(data16)) {
+                        const err42 = { instancePath: instancePath + "/viewport/rightOffsetDistance", schemaPath: "#/$defs/timeSeriesViewport/properties/rightOffsetDistance/maximum", keyword: "maximum", params: { comparison: "<=", limit: 10000 }, message: "must be <= 10000" };
+                        if (vErrors === null) {
+                            vErrors = [err42];
+                        }
+                        else {
+                            vErrors.push(err42);
+                        }
+                        errors++;
+                    }
+                    if (data16 < 0 || isNaN(data16)) {
+                        const err43 = { instancePath: instancePath + "/viewport/rightOffsetDistance", schemaPath: "#/$defs/timeSeriesViewport/properties/rightOffsetDistance/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                        if (vErrors === null) {
+                            vErrors = [err43];
+                        }
+                        else {
+                            vErrors.push(err43);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err44 = { instancePath: instancePath + "/viewport/rightOffsetDistance", schemaPath: "#/$defs/timeSeriesViewport/properties/rightOffsetDistance/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                        vErrors = [err44];
+                    }
+                    else {
+                        vErrors.push(err44);
+                    }
+                    errors++;
+                }
+            }
+            if (data14.anchorTimestamp !== undefined) {
+                let data17 = data14.anchorTimestamp;
+                if (!(((typeof data17 == "number") && (!(data17 % 1) && !isNaN(data17))) && (isFinite(data17)))) {
+                    const err45 = { instancePath: instancePath + "/viewport/anchorTimestamp", schemaPath: "#/$defs/timeSeriesViewport/properties/anchorTimestamp/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                    if (vErrors === null) {
+                        vErrors = [err45];
+                    }
+                    else {
+                        vErrors.push(err45);
+                    }
+                    errors++;
+                }
+                if ((typeof data17 == "number") && (isFinite(data17))) {
+                    if (data17 > 9007199254740991 || isNaN(data17)) {
+                        const err46 = { instancePath: instancePath + "/viewport/anchorTimestamp", schemaPath: "#/$defs/timeSeriesViewport/properties/anchorTimestamp/maximum", keyword: "maximum", params: { comparison: "<=", limit: 9007199254740991 }, message: "must be <= 9007199254740991" };
+                        if (vErrors === null) {
+                            vErrors = [err46];
+                        }
+                        else {
+                            vErrors.push(err46);
+                        }
+                        errors++;
+                    }
+                    if (data17 < 1 || isNaN(data17)) {
+                        const err47 = { instancePath: instancePath + "/viewport/anchorTimestamp", schemaPath: "#/$defs/timeSeriesViewport/properties/anchorTimestamp/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                        if (vErrors === null) {
+                            vErrors = [err47];
+                        }
+                        else {
+                            vErrors.push(err47);
+                        }
+                        errors++;
+                    }
+                }
+            }
+        }
+        else {
+            const err48 = { instancePath: instancePath + "/viewport", schemaPath: "#/$defs/timeSeriesViewport/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err48];
+            }
+            else {
+                vErrors.push(err48);
+            }
+            errors++;
+        }
+    }
+    if (data.render !== undefined) {
+        if (!(validate30(data.render, { instancePath: instancePath + "/render", parentData: data, parentDataProperty: "render", rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate30.errors : vErrors.concat(validate30.errors);
+            errors = vErrors.length;
+        }
+    }
+    if (data.metadata !== undefined) {
+        if (!(validate32(data.metadata, { instancePath: instancePath + "/metadata", parentData: data, parentDataProperty: "metadata", rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+            errors = vErrors.length;
+        }
+    }
+}
+else {
+    const err49 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err49];
+    }
+    else {
+        vErrors.push(err49);
+    }
+    errors++;
+} validate20.errors = vErrors; return errors === 0; }
+validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };