yarramate 1.25.0 → 1.25.2

package/dist/schema-validators.generated.js

@@ -9,7 +9,7 @@
 // file and not a runtime one; the two pure helpers imported below are
 // all the runtime still takes from ajv.
 //
-// schema/ sha256: 047e27f42a2bbeaf186894dad22fea47af390a5f299667cca2e70b20873fbf05
+// schema/ sha256: 00cb6c9fd71eaa7353b5463dfc7206df81c621e98e0edf47cb6cc0dba539b3b1
 import ajvRuntime0Module from 'ajv/dist/runtime/ucs2length.js';
 const ajvRuntime0 = ajvRuntime0Module.default ?? ajvRuntime0Module;
 import ajvRuntime1Module from 'ajv/dist/runtime/equal.js';
@@ -11864,3 +11864,594 @@ else {
     errors++;
 } validate74.errors = vErrors; return errors === 0; }
 validate74.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateVisualLayout = validate82;
+const schema187 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://yarramate.org/schema/visual-layout/v1", "title": "YarraMate visual layout", "description": "Adapter-owned drag-position sidecar for one saved projection's canvas (ADR 0023). Never validated by Core, never routed through apply.", "type": "object", "additionalProperties": false, "required": ["format", "projectionId", "positions"], "properties": { "format": { "const": "yarramate/visual-layout/v1" }, "projectionId": { "$ref": "https://yarramate.org/schema/projection/v1#/$defs/id" }, "positions": { "$ref": "#/$defs/positions" }, "folded": { "description": "The instances this view draws folded (#473). Written WITH the positions in the same document and always in full, never as a patch: a reader that half-applies a fold state draws a box whose contents are somewhere else on the canvas. Absent means the view's own `presentation.fold` decides.", "$ref": "#/$defs/subjectIds" }, "unfolded": { "description": "The instances this view draws OPEN even though `presentation.fold` says to fold them (#473). Two lists rather than one, because a reader who opened a box must not have it close again the moment the view's default is read back.", "$ref": "#/$defs/subjectIds" }, "routes": { "description": "The routes the canvas was drawing when the positions were saved (ADR 0147), keyed by relationship id, in absolute canvas coordinates from the source end. A route is applied only while both of its ends still sit where `positions` says; an edge whose end has moved draws straight. Absent means the layout recomputes every route.", "$ref": "#/$defs/routes" } }, "$defs": { "subjectIds": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } }, "positions": { "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/position" } }, "position": { "type": "object", "additionalProperties": false, "required": ["x", "y"], "properties": { "x": { "type": "number" }, "y": { "type": "number" } } }, "routes": { "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/route" } }, "route": { "type": "object", "additionalProperties": false, "required": ["points", "labelAt"], "properties": { "points": { "description": "Source end first, both endpoints included, so a route is never fewer than two points.", "type": "array", "minItems": 2, "items": { "$ref": "#/$defs/position" } }, "labelAt": { "description": "How far along the route, in px from the source end, the label's centre sits; null for a route with no label.", "type": ["number", "null"] } } } } };
+const schema191 = { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } };
+const schema189 = { "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/position" } };
+const schema190 = { "type": "object", "additionalProperties": false, "required": ["x", "y"], "properties": { "x": { "type": "number" }, "y": { "type": "number" } } };
+function validate83(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate83.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    for (const key0 in data) {
+        const _errs1 = errors;
+        if (typeof key0 === "string") {
+            if (func2(key0) < 1) {
+                const err0 = { instancePath, schemaPath: "#/propertyNames/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters", propertyName: key0 };
+                if (vErrors === null) {
+                    vErrors = [err0];
+                }
+                else {
+                    vErrors.push(err0);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err1 = { instancePath, schemaPath: "#/propertyNames/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key0 };
+            if (vErrors === null) {
+                vErrors = [err1];
+            }
+            else {
+                vErrors.push(err1);
+            }
+            errors++;
+        }
+        var valid0 = _errs1 === errors;
+        if (!valid0) {
+            const err2 = { instancePath, schemaPath: "#/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+            if (vErrors === null) {
+                vErrors = [err2];
+            }
+            else {
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+    for (const key1 in data) {
+        let data0 = data[key1];
+        if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+            if (data0.x === undefined) {
+                const err3 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/position/required", keyword: "required", params: { missingProperty: "x" }, message: "must have required property '" + "x" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            if (data0.y === undefined) {
+                const err4 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/position/required", keyword: "required", params: { missingProperty: "y" }, message: "must have required property '" + "y" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err4];
+                }
+                else {
+                    vErrors.push(err4);
+                }
+                errors++;
+            }
+            for (const key2 in data0) {
+                if (!((key2 === "x") || (key2 === "y"))) {
+                    const err5 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/position/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err5];
+                    }
+                    else {
+                        vErrors.push(err5);
+                    }
+                    errors++;
+                }
+            }
+            if (data0.x !== undefined) {
+                let data1 = data0.x;
+                if (!((typeof data1 == "number") && (isFinite(data1)))) {
+                    const err6 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/x", schemaPath: "#/$defs/position/properties/x/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                        vErrors = [err6];
+                    }
+                    else {
+                        vErrors.push(err6);
+                    }
+                    errors++;
+                }
+            }
+            if (data0.y !== undefined) {
+                let data2 = data0.y;
+                if (!((typeof data2 == "number") && (isFinite(data2)))) {
+                    const err7 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/y", schemaPath: "#/$defs/position/properties/y/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                        vErrors = [err7];
+                    }
+                    else {
+                        vErrors.push(err7);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err8 = { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/position/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err9 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err9];
+    }
+    else {
+        vErrors.push(err9);
+    }
+    errors++;
+} validate83.errors = vErrors; return errors === 0; }
+validate83.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+const schema193 = { "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/route" } };
+const schema194 = { "type": "object", "additionalProperties": false, "required": ["points", "labelAt"], "properties": { "points": { "description": "Source end first, both endpoints included, so a route is never fewer than two points.", "type": "array", "minItems": 2, "items": { "$ref": "#/$defs/position" } }, "labelAt": { "description": "How far along the route, in px from the source end, the label's centre sits; null for a route with no label.", "type": ["number", "null"] } } };
+function validate86(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate86.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.points === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "points" }, message: "must have required property '" + "points" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.labelAt === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "labelAt" }, message: "must have required property '" + "labelAt" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!((key0 === "points") || (key0 === "labelAt"))) {
+            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.points !== undefined) {
+        let data0 = data.points;
+        if (Array.isArray(data0)) {
+            if (data0.length < 2) {
+                const err3 = { instancePath: instancePath + "/points", schemaPath: "#/properties/points/minItems", keyword: "minItems", params: { limit: 2 }, message: "must NOT have fewer than 2 items" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            const len0 = data0.length;
+            for (let i0 = 0; i0 < len0; i0++) {
+                let data1 = data0[i0];
+                if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                    if (data1.x === undefined) {
+                        const err4 = { instancePath: instancePath + "/points/" + i0, schemaPath: "#/$defs/position/required", keyword: "required", params: { missingProperty: "x" }, message: "must have required property '" + "x" + "'" };
+                        if (vErrors === null) {
+                            vErrors = [err4];
+                        }
+                        else {
+                            vErrors.push(err4);
+                        }
+                        errors++;
+                    }
+                    if (data1.y === undefined) {
+                        const err5 = { instancePath: instancePath + "/points/" + i0, schemaPath: "#/$defs/position/required", keyword: "required", params: { missingProperty: "y" }, message: "must have required property '" + "y" + "'" };
+                        if (vErrors === null) {
+                            vErrors = [err5];
+                        }
+                        else {
+                            vErrors.push(err5);
+                        }
+                        errors++;
+                    }
+                    for (const key1 in data1) {
+                        if (!((key1 === "x") || (key1 === "y"))) {
+                            const err6 = { instancePath: instancePath + "/points/" + i0, schemaPath: "#/$defs/position/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                            if (vErrors === null) {
+                                vErrors = [err6];
+                            }
+                            else {
+                                vErrors.push(err6);
+                            }
+                            errors++;
+                        }
+                    }
+                    if (data1.x !== undefined) {
+                        let data2 = data1.x;
+                        if (!((typeof data2 == "number") && (isFinite(data2)))) {
+                            const err7 = { instancePath: instancePath + "/points/" + i0 + "/x", schemaPath: "#/$defs/position/properties/x/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                            if (vErrors === null) {
+                                vErrors = [err7];
+                            }
+                            else {
+                                vErrors.push(err7);
+                            }
+                            errors++;
+                        }
+                    }
+                    if (data1.y !== undefined) {
+                        let data3 = data1.y;
+                        if (!((typeof data3 == "number") && (isFinite(data3)))) {
+                            const err8 = { instancePath: instancePath + "/points/" + i0 + "/y", schemaPath: "#/$defs/position/properties/y/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                            if (vErrors === null) {
+                                vErrors = [err8];
+                            }
+                            else {
+                                vErrors.push(err8);
+                            }
+                            errors++;
+                        }
+                    }
+                }
+                else {
+                    const err9 = { instancePath: instancePath + "/points/" + i0, schemaPath: "#/$defs/position/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                        vErrors = [err9];
+                    }
+                    else {
+                        vErrors.push(err9);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err10 = { instancePath: instancePath + "/points", schemaPath: "#/properties/points/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err10];
+            }
+            else {
+                vErrors.push(err10);
+            }
+            errors++;
+        }
+    }
+    if (data.labelAt !== undefined) {
+        let data4 = data.labelAt;
+        if ((!((typeof data4 == "number") && (isFinite(data4)))) && (data4 !== null)) {
+            const err11 = { instancePath: instancePath + "/labelAt", schemaPath: "#/properties/labelAt/type", keyword: "type", params: { type: schema194.properties.labelAt.type }, message: "must be number,null" };
+            if (vErrors === null) {
+                vErrors = [err11];
+            }
+            else {
+                vErrors.push(err11);
+            }
+            errors++;
+        }
+    }
+}
+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++;
+} validate86.errors = vErrors; return errors === 0; }
+validate86.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate85(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate85.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    for (const key0 in data) {
+        const _errs1 = errors;
+        if (typeof key0 === "string") {
+            if (func2(key0) < 1) {
+                const err0 = { instancePath, schemaPath: "#/propertyNames/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters", propertyName: key0 };
+                if (vErrors === null) {
+                    vErrors = [err0];
+                }
+                else {
+                    vErrors.push(err0);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err1 = { instancePath, schemaPath: "#/propertyNames/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key0 };
+            if (vErrors === null) {
+                vErrors = [err1];
+            }
+            else {
+                vErrors.push(err1);
+            }
+            errors++;
+        }
+        var valid0 = _errs1 === errors;
+        if (!valid0) {
+            const err2 = { instancePath, schemaPath: "#/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+            if (vErrors === null) {
+                vErrors = [err2];
+            }
+            else {
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+    for (const key1 in data) {
+        if (!(validate86(data[key1], { instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data, parentDataProperty: key1, rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate86.errors : vErrors.concat(validate86.errors);
+            errors = vErrors.length;
+        }
+    }
+}
+else {
+    const err3 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err3];
+    }
+    else {
+        vErrors.push(err3);
+    }
+    errors++;
+} validate85.errors = vErrors; return errors === 0; }
+validate85.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate82(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://yarramate.org/schema/visual-layout/v1" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate82.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.format === undefined) {
+        const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "format" }, message: "must have required property '" + "format" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.projectionId === undefined) {
+        const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "projectionId" }, message: "must have required property '" + "projectionId" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.positions === undefined) {
+        const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "positions" }, message: "must have required property '" + "positions" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!((((((key0 === "format") || (key0 === "projectionId")) || (key0 === "positions")) || (key0 === "folded")) || (key0 === "unfolded")) || (key0 === "routes"))) {
+            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.format !== undefined) {
+        if ("yarramate/visual-layout/v1" !== data.format) {
+            const err4 = { instancePath: instancePath + "/format", schemaPath: "#/properties/format/const", keyword: "const", params: { allowedValue: "yarramate/visual-layout/v1" }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err4];
+            }
+            else {
+                vErrors.push(err4);
+            }
+            errors++;
+        }
+    }
+    if (data.projectionId !== undefined) {
+        let data1 = data.projectionId;
+        if (typeof data1 === "string") {
+            if (!pattern4.test(data1)) {
+                const err5 = { instancePath: instancePath + "/projectionId", schemaPath: "https://yarramate.org/schema/projection/v1#/$defs/id/pattern", keyword: "pattern", params: { pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" }, message: "must match pattern \"" + "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" + "\"" };
+                if (vErrors === null) {
+                    vErrors = [err5];
+                }
+                else {
+                    vErrors.push(err5);
+                }
+                errors++;
+            }
+        }
+        else {
+            const err6 = { instancePath: instancePath + "/projectionId", schemaPath: "https://yarramate.org/schema/projection/v1#/$defs/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err6];
+            }
+            else {
+                vErrors.push(err6);
+            }
+            errors++;
+        }
+    }
+    if (data.positions !== undefined) {
+        if (!(validate83(data.positions, { instancePath: instancePath + "/positions", parentData: data, parentDataProperty: "positions", rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate83.errors : vErrors.concat(validate83.errors);
+            errors = vErrors.length;
+        }
+    }
+    if (data.folded !== undefined) {
+        let data3 = data.folded;
+        if (Array.isArray(data3)) {
+            const len0 = data3.length;
+            for (let i0 = 0; i0 < len0; i0++) {
+                let data4 = data3[i0];
+                if (typeof data4 === "string") {
+                    if (func2(data4) < 1) {
+                        const err7 = { instancePath: instancePath + "/folded/" + i0, schemaPath: "#/$defs/subjectIds/items/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                        if (vErrors === null) {
+                            vErrors = [err7];
+                        }
+                        else {
+                            vErrors.push(err7);
+                        }
+                        errors++;
+                    }
+                }
+                else {
+                    const err8 = { instancePath: instancePath + "/folded/" + i0, schemaPath: "#/$defs/subjectIds/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err8];
+                    }
+                    else {
+                        vErrors.push(err8);
+                    }
+                    errors++;
+                }
+            }
+            let i1 = data3.length;
+            let j0;
+            if (i1 > 1) {
+                const indices0 = {};
+                for (; i1--;) {
+                    let item0 = data3[i1];
+                    if (typeof item0 !== "string") {
+                        continue;
+                    }
+                    if (typeof indices0[item0] == "number") {
+                        j0 = indices0[item0];
+                        const err9 = { instancePath: instancePath + "/folded", schemaPath: "#/$defs/subjectIds/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" };
+                        if (vErrors === null) {
+                            vErrors = [err9];
+                        }
+                        else {
+                            vErrors.push(err9);
+                        }
+                        errors++;
+                        break;
+                    }
+                    indices0[item0] = i1;
+                }
+            }
+        }
+        else {
+            const err10 = { instancePath: instancePath + "/folded", schemaPath: "#/$defs/subjectIds/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err10];
+            }
+            else {
+                vErrors.push(err10);
+            }
+            errors++;
+        }
+    }
+    if (data.unfolded !== undefined) {
+        let data5 = data.unfolded;
+        if (Array.isArray(data5)) {
+            const len1 = data5.length;
+            for (let i2 = 0; i2 < len1; i2++) {
+                let data6 = data5[i2];
+                if (typeof data6 === "string") {
+                    if (func2(data6) < 1) {
+                        const err11 = { instancePath: instancePath + "/unfolded/" + i2, schemaPath: "#/$defs/subjectIds/items/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 + "/unfolded/" + i2, schemaPath: "#/$defs/subjectIds/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err12];
+                    }
+                    else {
+                        vErrors.push(err12);
+                    }
+                    errors++;
+                }
+            }
+            let i3 = data5.length;
+            let j1;
+            if (i3 > 1) {
+                const indices1 = {};
+                for (; i3--;) {
+                    let item1 = data5[i3];
+                    if (typeof item1 !== "string") {
+                        continue;
+                    }
+                    if (typeof indices1[item1] == "number") {
+                        j1 = indices1[item1];
+                        const err13 = { instancePath: instancePath + "/unfolded", schemaPath: "#/$defs/subjectIds/uniqueItems", keyword: "uniqueItems", params: { i: i3, j: j1 }, message: "must NOT have duplicate items (items ## " + j1 + " and " + i3 + " are identical)" };
+                        if (vErrors === null) {
+                            vErrors = [err13];
+                        }
+                        else {
+                            vErrors.push(err13);
+                        }
+                        errors++;
+                        break;
+                    }
+                    indices1[item1] = i3;
+                }
+            }
+        }
+        else {
+            const err14 = { instancePath: instancePath + "/unfolded", schemaPath: "#/$defs/subjectIds/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err14];
+            }
+            else {
+                vErrors.push(err14);
+            }
+            errors++;
+        }
+    }
+    if (data.routes !== undefined) {
+        if (!(validate85(data.routes, { instancePath: instancePath + "/routes", parentData: data, parentDataProperty: "routes", rootData, dynamicAnchors }))) {
+            vErrors = vErrors === null ? validate85.errors : vErrors.concat(validate85.errors);
+            errors = vErrors.length;
+        }
+    }
+}
+else {
+    const err15 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err15];
+    }
+    else {
+        vErrors.push(err15);
+    }
+    errors++;
+} validate82.errors = vErrors; return errors === 0; }
+validate82.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };