@lvl99dotcom/paintcanvas 0.3.1 → 0.5.0

package/dist/lib/validation/validators.generated.js

@@ -19823,4 +19823,1043 @@ function validate15(data, { instancePath = "", parentData, parentDataProperty, r
 	validate15.errors = vErrors;
 	return true;
 }
-export { validateBrushPreset, validateBrushPresetFile, validateDocument, validateHistoryMessage, validatePatchMessage, validateStrokeMessage };
+var validatePaletteFile = validate16;
+function validate16(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+	let vErrors = null;
+	if (data && typeof data == "object" && !Array.isArray(data)) {
+		let missing0;
+		if (data.format === void 0 && (missing0 = "format") || data.version === void 0 && (missing0 = "version") || data.colours === void 0 && (missing0 = "colours")) {
+			validate16.errors = [{
+				instancePath,
+				schemaPath: "#/required",
+				keyword: "required",
+				params: { missingProperty: missing0 },
+				message: "must have required property '" + missing0 + "'"
+			}];
+			return false;
+		} else {
+			for (const key0 in data) if (!(key0 === "format" || key0 === "version" || key0 === "colours")) {
+				validate16.errors = [{
+					instancePath,
+					schemaPath: "#/additionalProperties",
+					keyword: "additionalProperties",
+					params: { additionalProperty: key0 },
+					message: "must NOT have additional properties"
+				}];
+				return false;
+			}
+			if (data.format !== void 0) {
+				let data0 = data.format;
+				if (typeof data0 === "string") {
+					if (data0.length > 100) {
+						validate16.errors = [{
+							instancePath: instancePath + "/format",
+							schemaPath: "#/properties/format/maxLength",
+							keyword: "maxLength",
+							params: { limit: 100 },
+							message: "must NOT have more than 100 characters"
+						}];
+						return false;
+					} else if (data0.length < 1) {
+						validate16.errors = [{
+							instancePath: instancePath + "/format",
+							schemaPath: "#/properties/format/minLength",
+							keyword: "minLength",
+							params: { limit: 1 },
+							message: "must NOT have fewer than 1 characters"
+						}];
+						return false;
+					}
+				} else {
+					validate16.errors = [{
+						instancePath: instancePath + "/format",
+						schemaPath: "#/properties/format/type",
+						keyword: "type",
+						params: { type: "string" },
+						message: "must be string"
+					}];
+					return false;
+				}
+				var valid0 = true;
+			} else var valid0 = true;
+			if (valid0) {
+				if (data.version !== void 0) {
+					if (1 !== data.version) {
+						validate16.errors = [{
+							instancePath: instancePath + "/version",
+							schemaPath: "#/properties/version/const",
+							keyword: "const",
+							params: { allowedValue: 1 },
+							message: "must be equal to constant"
+						}];
+						return false;
+					}
+					var valid0 = true;
+				} else var valid0 = true;
+				if (valid0) {
+					if (data.colours !== void 0) {
+						let data2 = data.colours;
+						if (Array.isArray(data2)) {
+							if (data2.length > 1e3) {
+								validate16.errors = [{
+									instancePath: instancePath + "/colours",
+									schemaPath: "#/properties/colours/maxItems",
+									keyword: "maxItems",
+									params: { limit: 1e3 },
+									message: "must NOT have more than 1000 items"
+								}];
+								return false;
+							} else {
+								const len0 = data2.length;
+								for (let i0 = 0; i0 < len0; i0++) {
+									let data3 = data2[i0];
+									if (typeof data3 === "string") {
+										if (!pattern7.test(data3)) {
+											validate16.errors = [{
+												instancePath: instancePath + "/colours/" + i0,
+												schemaPath: "#/properties/colours/items/pattern",
+												keyword: "pattern",
+												params: { pattern: "^#[0-9a-fA-F]{6}$" },
+												message: "must match pattern \"^#[0-9a-fA-F]{6}$\""
+											}];
+											return false;
+										}
+									} else {
+										validate16.errors = [{
+											instancePath: instancePath + "/colours/" + i0,
+											schemaPath: "#/properties/colours/items/type",
+											keyword: "type",
+											params: { type: "string" },
+											message: "must be string"
+										}];
+										return false;
+									}
+								}
+							}
+						} else {
+							validate16.errors = [{
+								instancePath: instancePath + "/colours",
+								schemaPath: "#/properties/colours/type",
+								keyword: "type",
+								params: { type: "array" },
+								message: "must be array"
+							}];
+							return false;
+						}
+						var valid0 = true;
+					} else var valid0 = true;
+				}
+			}
+		}
+	} else {
+		validate16.errors = [{
+			instancePath,
+			schemaPath: "#/type",
+			keyword: "type",
+			params: { type: "object" },
+			message: "must be object"
+		}];
+		return false;
+	}
+	validate16.errors = vErrors;
+	return true;
+}
+var validateSettings = validate17;
+var schema20 = {
+	"$id": "paintcanvas/settings",
+	"type": "object",
+	"additionalProperties": false,
+	"properties": {
+		"input": {
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"scrollPan": { "type": "boolean" },
+				"pinchZoom": { "type": "boolean" },
+				"modifierScrollZoom": { "type": "boolean" },
+				"focusPen": { "type": "boolean" },
+				"gestures": {
+					"type": "object",
+					"maxProperties": 20,
+					"additionalProperties": {
+						"type": "string",
+						"maxLength": 50
+					}
+				}
+			}
+		},
+		"shortcuts": {
+			"type": "object",
+			"maxProperties": 200,
+			"propertyNames": { "maxLength": 64 },
+			"additionalProperties": { "anyOf": [{ "type": "null" }, { "$ref": "key-combo" }] }
+		},
+		"palette": {
+			"type": "array",
+			"maxItems": 1e3,
+			"items": {
+				"type": "string",
+				"pattern": "^#[0-9a-fA-F]{6}$"
+			}
+		},
+		"colours": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["foreground", "background"],
+			"properties": {
+				"foreground": {
+					"type": "string",
+					"pattern": "^#[0-9a-fA-F]{6}$"
+				},
+				"background": {
+					"type": "string",
+					"pattern": "^#[0-9a-fA-F]{6}$"
+				}
+			}
+		},
+		"ui": {
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"theme": { "enum": [
+					"light",
+					"dark",
+					"system"
+				] },
+				"locale": {
+					"type": "string",
+					"minLength": 1,
+					"maxLength": 35,
+					"pattern": "^[A-Za-z0-9-]+$"
+				}
+			}
+		}
+	}
+};
+var pattern16 = /* @__PURE__ */ new RegExp("^[A-Za-z0-9-]+$", "u");
+function validate17(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+	let vErrors = null;
+	let errors = 0;
+	if (errors === 0) {
+		if (data && typeof data == "object" && !Array.isArray(data)) {
+			const _errs1 = errors;
+			for (const key0 in data) if (!(key0 === "input" || key0 === "shortcuts" || key0 === "palette" || key0 === "colours" || key0 === "ui")) {
+				validate17.errors = [{
+					instancePath,
+					schemaPath: "#/additionalProperties",
+					keyword: "additionalProperties",
+					params: { additionalProperty: key0 },
+					message: "must NOT have additional properties"
+				}];
+				return false;
+			}
+			if (_errs1 === errors) {
+				if (data.input !== void 0) {
+					let data0 = data.input;
+					const _errs2 = errors;
+					if (errors === _errs2) {
+						if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+							const _errs4 = errors;
+							for (const key1 in data0) if (!(key1 === "scrollPan" || key1 === "pinchZoom" || key1 === "modifierScrollZoom" || key1 === "focusPen" || key1 === "gestures")) {
+								validate17.errors = [{
+									instancePath: instancePath + "/input",
+									schemaPath: "#/properties/input/additionalProperties",
+									keyword: "additionalProperties",
+									params: { additionalProperty: key1 },
+									message: "must NOT have additional properties"
+								}];
+								return false;
+							}
+							if (_errs4 === errors) {
+								if (data0.scrollPan !== void 0) {
+									const _errs5 = errors;
+									if (typeof data0.scrollPan !== "boolean") {
+										validate17.errors = [{
+											instancePath: instancePath + "/input/scrollPan",
+											schemaPath: "#/properties/input/properties/scrollPan/type",
+											keyword: "type",
+											params: { type: "boolean" },
+											message: "must be boolean"
+										}];
+										return false;
+									}
+									var valid1 = _errs5 === errors;
+								} else var valid1 = true;
+								if (valid1) {
+									if (data0.pinchZoom !== void 0) {
+										const _errs7 = errors;
+										if (typeof data0.pinchZoom !== "boolean") {
+											validate17.errors = [{
+												instancePath: instancePath + "/input/pinchZoom",
+												schemaPath: "#/properties/input/properties/pinchZoom/type",
+												keyword: "type",
+												params: { type: "boolean" },
+												message: "must be boolean"
+											}];
+											return false;
+										}
+										var valid1 = _errs7 === errors;
+									} else var valid1 = true;
+									if (valid1) {
+										if (data0.modifierScrollZoom !== void 0) {
+											const _errs9 = errors;
+											if (typeof data0.modifierScrollZoom !== "boolean") {
+												validate17.errors = [{
+													instancePath: instancePath + "/input/modifierScrollZoom",
+													schemaPath: "#/properties/input/properties/modifierScrollZoom/type",
+													keyword: "type",
+													params: { type: "boolean" },
+													message: "must be boolean"
+												}];
+												return false;
+											}
+											var valid1 = _errs9 === errors;
+										} else var valid1 = true;
+										if (valid1) {
+											if (data0.focusPen !== void 0) {
+												const _errs11 = errors;
+												if (typeof data0.focusPen !== "boolean") {
+													validate17.errors = [{
+														instancePath: instancePath + "/input/focusPen",
+														schemaPath: "#/properties/input/properties/focusPen/type",
+														keyword: "type",
+														params: { type: "boolean" },
+														message: "must be boolean"
+													}];
+													return false;
+												}
+												var valid1 = _errs11 === errors;
+											} else var valid1 = true;
+											if (valid1) {
+												if (data0.gestures !== void 0) {
+													let data5 = data0.gestures;
+													const _errs13 = errors;
+													if (errors === _errs13) {
+														if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+															if (Object.keys(data5).length > 20) {
+																validate17.errors = [{
+																	instancePath: instancePath + "/input/gestures",
+																	schemaPath: "#/properties/input/properties/gestures/maxProperties",
+																	keyword: "maxProperties",
+																	params: { limit: 20 },
+																	message: "must NOT have more than 20 properties"
+																}];
+																return false;
+															} else for (const key2 in data5) {
+																let data6 = data5[key2];
+																const _errs16 = errors;
+																if (errors === _errs16) {
+																	if (typeof data6 === "string") {
+																		if (data6.length > 50) {
+																			validate17.errors = [{
+																				instancePath: instancePath + "/input/gestures/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"),
+																				schemaPath: "#/properties/input/properties/gestures/additionalProperties/maxLength",
+																				keyword: "maxLength",
+																				params: { limit: 50 },
+																				message: "must NOT have more than 50 characters"
+																			}];
+																			return false;
+																		}
+																	} else {
+																		validate17.errors = [{
+																			instancePath: instancePath + "/input/gestures/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"),
+																			schemaPath: "#/properties/input/properties/gestures/additionalProperties/type",
+																			keyword: "type",
+																			params: { type: "string" },
+																			message: "must be string"
+																		}];
+																		return false;
+																	}
+																}
+																if (!(_errs16 === errors)) break;
+															}
+														} else {
+															validate17.errors = [{
+																instancePath: instancePath + "/input/gestures",
+																schemaPath: "#/properties/input/properties/gestures/type",
+																keyword: "type",
+																params: { type: "object" },
+																message: "must be object"
+															}];
+															return false;
+														}
+													}
+													var valid1 = _errs13 === errors;
+												} else var valid1 = true;
+											}
+										}
+									}
+								}
+							}
+						} else {
+							validate17.errors = [{
+								instancePath: instancePath + "/input",
+								schemaPath: "#/properties/input/type",
+								keyword: "type",
+								params: { type: "object" },
+								message: "must be object"
+							}];
+							return false;
+						}
+					}
+					var valid0 = _errs2 === errors;
+				} else var valid0 = true;
+				if (valid0) {
+					if (data.shortcuts !== void 0) {
+						let data7 = data.shortcuts;
+						const _errs18 = errors;
+						if (errors === _errs18) {
+							if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+								if (Object.keys(data7).length > 200) {
+									validate17.errors = [{
+										instancePath: instancePath + "/shortcuts",
+										schemaPath: "#/properties/shortcuts/maxProperties",
+										keyword: "maxProperties",
+										params: { limit: 200 },
+										message: "must NOT have more than 200 properties"
+									}];
+									return false;
+								} else {
+									for (const key3 in data7) {
+										const _errs20 = errors;
+										if (typeof key3 === "string") {
+											if (key3.length > 64) {
+												const err0 = {
+													instancePath: instancePath + "/shortcuts",
+													schemaPath: "#/properties/shortcuts/propertyNames/maxLength",
+													keyword: "maxLength",
+													params: { limit: 64 },
+													message: "must NOT have more than 64 characters",
+													propertyName: key3
+												};
+												if (vErrors === null) vErrors = [err0];
+												else vErrors.push(err0);
+												errors++;
+											}
+										}
+										var valid3 = _errs20 === errors;
+										if (!valid3) {
+											const err1 = {
+												instancePath: instancePath + "/shortcuts",
+												schemaPath: "#/properties/shortcuts/propertyNames",
+												keyword: "propertyNames",
+												params: { propertyName: key3 },
+												message: "property name must be valid"
+											};
+											if (vErrors === null) vErrors = [err1];
+											else vErrors.push(err1);
+											errors++;
+											validate17.errors = vErrors;
+											return false;
+										}
+									}
+									if (valid3) for (const key4 in data7) {
+										let data8 = data7[key4];
+										const _errs22 = errors;
+										const _errs23 = errors;
+										let valid5 = false;
+										const _errs24 = errors;
+										if (data8 !== null) {
+											const err2 = {
+												instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"),
+												schemaPath: "#/properties/shortcuts/additionalProperties/anyOf/0/type",
+												keyword: "type",
+												params: { type: "null" },
+												message: "must be null"
+											};
+											if (vErrors === null) vErrors = [err2];
+											else vErrors.push(err2);
+											errors++;
+										}
+										var _valid0 = _errs24 === errors;
+										valid5 = valid5 || _valid0;
+										if (!valid5) {
+											const _errs26 = errors;
+											if (errors === errors) {
+												if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+													let missing0;
+													if (data8.key === void 0 && (missing0 = "key")) {
+														const err3 = {
+															instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"),
+															schemaPath: "key-combo/required",
+															keyword: "required",
+															params: { missingProperty: missing0 },
+															message: "must have required property '" + missing0 + "'"
+														};
+														if (vErrors === null) vErrors = [err3];
+														else vErrors.push(err3);
+														errors++;
+													} else {
+														const _errs29 = errors;
+														for (const key5 in data8) if (!(key5 === "key" || key5 === "cmd" || key5 === "ctrl" || key5 === "shift" || key5 === "alt")) {
+															const err4 = {
+																instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"),
+																schemaPath: "key-combo/additionalProperties",
+																keyword: "additionalProperties",
+																params: { additionalProperty: key5 },
+																message: "must NOT have additional properties"
+															};
+															if (vErrors === null) vErrors = [err4];
+															else vErrors.push(err4);
+															errors++;
+															break;
+														}
+														if (_errs29 === errors) {
+															if (data8.key !== void 0) {
+																let data9 = data8.key;
+																const _errs30 = errors;
+																if (errors === _errs30) {
+																	if (typeof data9 === "string") {
+																		if (data9.length > 32) {
+																			const err5 = {
+																				instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/key",
+																				schemaPath: "key-combo/properties/key/maxLength",
+																				keyword: "maxLength",
+																				params: { limit: 32 },
+																				message: "must NOT have more than 32 characters"
+																			};
+																			if (vErrors === null) vErrors = [err5];
+																			else vErrors.push(err5);
+																			errors++;
+																		} else if (data9.length < 1) {
+																			const err6 = {
+																				instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/key",
+																				schemaPath: "key-combo/properties/key/minLength",
+																				keyword: "minLength",
+																				params: { limit: 1 },
+																				message: "must NOT have fewer than 1 characters"
+																			};
+																			if (vErrors === null) vErrors = [err6];
+																			else vErrors.push(err6);
+																			errors++;
+																		}
+																	} else {
+																		const err7 = {
+																			instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/key",
+																			schemaPath: "key-combo/properties/key/type",
+																			keyword: "type",
+																			params: { type: "string" },
+																			message: "must be string"
+																		};
+																		if (vErrors === null) vErrors = [err7];
+																		else vErrors.push(err7);
+																		errors++;
+																	}
+																}
+																var valid7 = _errs30 === errors;
+															} else var valid7 = true;
+															if (valid7) {
+																if (data8.cmd !== void 0) {
+																	const _errs32 = errors;
+																	if (typeof data8.cmd !== "boolean") {
+																		const err8 = {
+																			instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/cmd",
+																			schemaPath: "key-combo/properties/cmd/type",
+																			keyword: "type",
+																			params: { type: "boolean" },
+																			message: "must be boolean"
+																		};
+																		if (vErrors === null) vErrors = [err8];
+																		else vErrors.push(err8);
+																		errors++;
+																	}
+																	var valid7 = _errs32 === errors;
+																} else var valid7 = true;
+																if (valid7) {
+																	if (data8.ctrl !== void 0) {
+																		const _errs34 = errors;
+																		if (typeof data8.ctrl !== "boolean") {
+																			const err9 = {
+																				instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/ctrl",
+																				schemaPath: "key-combo/properties/ctrl/type",
+																				keyword: "type",
+																				params: { type: "boolean" },
+																				message: "must be boolean"
+																			};
+																			if (vErrors === null) vErrors = [err9];
+																			else vErrors.push(err9);
+																			errors++;
+																		}
+																		var valid7 = _errs34 === errors;
+																	} else var valid7 = true;
+																	if (valid7) {
+																		if (data8.shift !== void 0) {
+																			const _errs36 = errors;
+																			if (typeof data8.shift !== "boolean") {
+																				const err10 = {
+																					instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/shift",
+																					schemaPath: "key-combo/properties/shift/type",
+																					keyword: "type",
+																					params: { type: "boolean" },
+																					message: "must be boolean"
+																				};
+																				if (vErrors === null) vErrors = [err10];
+																				else vErrors.push(err10);
+																				errors++;
+																			}
+																			var valid7 = _errs36 === errors;
+																		} else var valid7 = true;
+																		if (valid7) {
+																			if (data8.alt !== void 0) {
+																				const _errs38 = errors;
+																				if (typeof data8.alt !== "boolean") {
+																					const err11 = {
+																						instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/alt",
+																						schemaPath: "key-combo/properties/alt/type",
+																						keyword: "type",
+																						params: { type: "boolean" },
+																						message: "must be boolean"
+																					};
+																					if (vErrors === null) vErrors = [err11];
+																					else vErrors.push(err11);
+																					errors++;
+																				}
+																				var valid7 = _errs38 === errors;
+																			} else var valid7 = true;
+																		}
+																	}
+																}
+															}
+														}
+													}
+												} else {
+													const err12 = {
+														instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"),
+														schemaPath: "key-combo/type",
+														keyword: "type",
+														params: { type: "object" },
+														message: "must be object"
+													};
+													if (vErrors === null) vErrors = [err12];
+													else vErrors.push(err12);
+													errors++;
+												}
+											}
+											var _valid0 = _errs26 === errors;
+											valid5 = valid5 || _valid0;
+										}
+										if (!valid5) {
+											const err13 = {
+												instancePath: instancePath + "/shortcuts/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"),
+												schemaPath: "#/properties/shortcuts/additionalProperties/anyOf",
+												keyword: "anyOf",
+												params: {},
+												message: "must match a schema in anyOf"
+											};
+											if (vErrors === null) vErrors = [err13];
+											else vErrors.push(err13);
+											errors++;
+											validate17.errors = vErrors;
+											return false;
+										} else {
+											errors = _errs23;
+											if (vErrors !== null) {
+												if (_errs23) vErrors.length = _errs23;
+												else vErrors = null;
+											}
+										}
+										if (!(_errs22 === errors)) break;
+									}
+								}
+							} else {
+								validate17.errors = [{
+									instancePath: instancePath + "/shortcuts",
+									schemaPath: "#/properties/shortcuts/type",
+									keyword: "type",
+									params: { type: "object" },
+									message: "must be object"
+								}];
+								return false;
+							}
+						}
+						var valid0 = _errs18 === errors;
+					} else var valid0 = true;
+					if (valid0) {
+						if (data.palette !== void 0) {
+							let data14 = data.palette;
+							const _errs40 = errors;
+							if (errors === _errs40) {
+								if (Array.isArray(data14)) {
+									if (data14.length > 1e3) {
+										validate17.errors = [{
+											instancePath: instancePath + "/palette",
+											schemaPath: "#/properties/palette/maxItems",
+											keyword: "maxItems",
+											params: { limit: 1e3 },
+											message: "must NOT have more than 1000 items"
+										}];
+										return false;
+									} else {
+										const len0 = data14.length;
+										for (let i0 = 0; i0 < len0; i0++) {
+											let data15 = data14[i0];
+											const _errs42 = errors;
+											if (errors === _errs42) {
+												if (typeof data15 === "string") {
+													if (!pattern7.test(data15)) {
+														validate17.errors = [{
+															instancePath: instancePath + "/palette/" + i0,
+															schemaPath: "#/properties/palette/items/pattern",
+															keyword: "pattern",
+															params: { pattern: "^#[0-9a-fA-F]{6}$" },
+															message: "must match pattern \"^#[0-9a-fA-F]{6}$\""
+														}];
+														return false;
+													}
+												} else {
+													validate17.errors = [{
+														instancePath: instancePath + "/palette/" + i0,
+														schemaPath: "#/properties/palette/items/type",
+														keyword: "type",
+														params: { type: "string" },
+														message: "must be string"
+													}];
+													return false;
+												}
+											}
+											if (!(_errs42 === errors)) break;
+										}
+									}
+								} else {
+									validate17.errors = [{
+										instancePath: instancePath + "/palette",
+										schemaPath: "#/properties/palette/type",
+										keyword: "type",
+										params: { type: "array" },
+										message: "must be array"
+									}];
+									return false;
+								}
+							}
+							var valid0 = _errs40 === errors;
+						} else var valid0 = true;
+						if (valid0) {
+							if (data.colours !== void 0) {
+								let data16 = data.colours;
+								const _errs44 = errors;
+								if (errors === _errs44) {
+									if (data16 && typeof data16 == "object" && !Array.isArray(data16)) {
+										let missing1;
+										if (data16.foreground === void 0 && (missing1 = "foreground") || data16.background === void 0 && (missing1 = "background")) {
+											validate17.errors = [{
+												instancePath: instancePath + "/colours",
+												schemaPath: "#/properties/colours/required",
+												keyword: "required",
+												params: { missingProperty: missing1 },
+												message: "must have required property '" + missing1 + "'"
+											}];
+											return false;
+										} else {
+											const _errs46 = errors;
+											for (const key6 in data16) if (!(key6 === "foreground" || key6 === "background")) {
+												validate17.errors = [{
+													instancePath: instancePath + "/colours",
+													schemaPath: "#/properties/colours/additionalProperties",
+													keyword: "additionalProperties",
+													params: { additionalProperty: key6 },
+													message: "must NOT have additional properties"
+												}];
+												return false;
+											}
+											if (_errs46 === errors) {
+												if (data16.foreground !== void 0) {
+													let data17 = data16.foreground;
+													const _errs47 = errors;
+													if (errors === _errs47) {
+														if (typeof data17 === "string") {
+															if (!pattern7.test(data17)) {
+																validate17.errors = [{
+																	instancePath: instancePath + "/colours/foreground",
+																	schemaPath: "#/properties/colours/properties/foreground/pattern",
+																	keyword: "pattern",
+																	params: { pattern: "^#[0-9a-fA-F]{6}$" },
+																	message: "must match pattern \"^#[0-9a-fA-F]{6}$\""
+																}];
+																return false;
+															}
+														} else {
+															validate17.errors = [{
+																instancePath: instancePath + "/colours/foreground",
+																schemaPath: "#/properties/colours/properties/foreground/type",
+																keyword: "type",
+																params: { type: "string" },
+																message: "must be string"
+															}];
+															return false;
+														}
+													}
+													var valid9 = _errs47 === errors;
+												} else var valid9 = true;
+												if (valid9) {
+													if (data16.background !== void 0) {
+														let data18 = data16.background;
+														const _errs49 = errors;
+														if (errors === _errs49) {
+															if (typeof data18 === "string") {
+																if (!pattern7.test(data18)) {
+																	validate17.errors = [{
+																		instancePath: instancePath + "/colours/background",
+																		schemaPath: "#/properties/colours/properties/background/pattern",
+																		keyword: "pattern",
+																		params: { pattern: "^#[0-9a-fA-F]{6}$" },
+																		message: "must match pattern \"^#[0-9a-fA-F]{6}$\""
+																	}];
+																	return false;
+																}
+															} else {
+																validate17.errors = [{
+																	instancePath: instancePath + "/colours/background",
+																	schemaPath: "#/properties/colours/properties/background/type",
+																	keyword: "type",
+																	params: { type: "string" },
+																	message: "must be string"
+																}];
+																return false;
+															}
+														}
+														var valid9 = _errs49 === errors;
+													} else var valid9 = true;
+												}
+											}
+										}
+									} else {
+										validate17.errors = [{
+											instancePath: instancePath + "/colours",
+											schemaPath: "#/properties/colours/type",
+											keyword: "type",
+											params: { type: "object" },
+											message: "must be object"
+										}];
+										return false;
+									}
+								}
+								var valid0 = _errs44 === errors;
+							} else var valid0 = true;
+							if (valid0) {
+								if (data.ui !== void 0) {
+									let data19 = data.ui;
+									const _errs51 = errors;
+									if (errors === _errs51) {
+										if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+											const _errs53 = errors;
+											for (const key7 in data19) if (!(key7 === "theme" || key7 === "locale")) {
+												validate17.errors = [{
+													instancePath: instancePath + "/ui",
+													schemaPath: "#/properties/ui/additionalProperties",
+													keyword: "additionalProperties",
+													params: { additionalProperty: key7 },
+													message: "must NOT have additional properties"
+												}];
+												return false;
+											}
+											if (_errs53 === errors) {
+												if (data19.theme !== void 0) {
+													let data20 = data19.theme;
+													const _errs54 = errors;
+													if (!(data20 === "light" || data20 === "dark" || data20 === "system")) {
+														validate17.errors = [{
+															instancePath: instancePath + "/ui/theme",
+															schemaPath: "#/properties/ui/properties/theme/enum",
+															keyword: "enum",
+															params: { allowedValues: schema20.properties.ui.properties.theme.enum },
+															message: "must be equal to one of the allowed values"
+														}];
+														return false;
+													}
+													var valid10 = _errs54 === errors;
+												} else var valid10 = true;
+												if (valid10) {
+													if (data19.locale !== void 0) {
+														let data21 = data19.locale;
+														const _errs55 = errors;
+														if (errors === _errs55) {
+															if (typeof data21 === "string") {
+																if (data21.length > 35) {
+																	validate17.errors = [{
+																		instancePath: instancePath + "/ui/locale",
+																		schemaPath: "#/properties/ui/properties/locale/maxLength",
+																		keyword: "maxLength",
+																		params: { limit: 35 },
+																		message: "must NOT have more than 35 characters"
+																	}];
+																	return false;
+																} else if (data21.length < 1) {
+																	validate17.errors = [{
+																		instancePath: instancePath + "/ui/locale",
+																		schemaPath: "#/properties/ui/properties/locale/minLength",
+																		keyword: "minLength",
+																		params: { limit: 1 },
+																		message: "must NOT have fewer than 1 characters"
+																	}];
+																	return false;
+																} else if (!pattern16.test(data21)) {
+																	validate17.errors = [{
+																		instancePath: instancePath + "/ui/locale",
+																		schemaPath: "#/properties/ui/properties/locale/pattern",
+																		keyword: "pattern",
+																		params: { pattern: "^[A-Za-z0-9-]+$" },
+																		message: "must match pattern \"^[A-Za-z0-9-]+$\""
+																	}];
+																	return false;
+																}
+															} else {
+																validate17.errors = [{
+																	instancePath: instancePath + "/ui/locale",
+																	schemaPath: "#/properties/ui/properties/locale/type",
+																	keyword: "type",
+																	params: { type: "string" },
+																	message: "must be string"
+																}];
+																return false;
+															}
+														}
+														var valid10 = _errs55 === errors;
+													} else var valid10 = true;
+												}
+											}
+										} else {
+											validate17.errors = [{
+												instancePath: instancePath + "/ui",
+												schemaPath: "#/properties/ui/type",
+												keyword: "type",
+												params: { type: "object" },
+												message: "must be object"
+											}];
+											return false;
+										}
+									}
+									var valid0 = _errs51 === errors;
+								} else var valid0 = true;
+							}
+						}
+					}
+				}
+			}
+		} else {
+			validate17.errors = [{
+				instancePath,
+				schemaPath: "#/type",
+				keyword: "type",
+				params: { type: "object" },
+				message: "must be object"
+			}];
+			return false;
+		}
+	}
+	validate17.errors = vErrors;
+	return errors === 0;
+}
+var validateSettingsFile = validate18;
+function validate18(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+	let vErrors = null;
+	let errors = 0;
+	if (errors === 0) {
+		if (data && typeof data == "object" && !Array.isArray(data)) {
+			let missing0;
+			if (data.format === void 0 && (missing0 = "format") || data.version === void 0 && (missing0 = "version") || data.settings === void 0 && (missing0 = "settings")) {
+				validate18.errors = [{
+					instancePath,
+					schemaPath: "#/required",
+					keyword: "required",
+					params: { missingProperty: missing0 },
+					message: "must have required property '" + missing0 + "'"
+				}];
+				return false;
+			} else {
+				const _errs1 = errors;
+				for (const key0 in data) if (!(key0 === "format" || key0 === "version" || key0 === "settings")) {
+					validate18.errors = [{
+						instancePath,
+						schemaPath: "#/additionalProperties",
+						keyword: "additionalProperties",
+						params: { additionalProperty: key0 },
+						message: "must NOT have additional properties"
+					}];
+					return false;
+				}
+				if (_errs1 === errors) {
+					if (data.format !== void 0) {
+						let data0 = data.format;
+						const _errs2 = errors;
+						if (errors === _errs2) {
+							if (typeof data0 === "string") {
+								if (data0.length > 100) {
+									validate18.errors = [{
+										instancePath: instancePath + "/format",
+										schemaPath: "#/properties/format/maxLength",
+										keyword: "maxLength",
+										params: { limit: 100 },
+										message: "must NOT have more than 100 characters"
+									}];
+									return false;
+								} else if (data0.length < 1) {
+									validate18.errors = [{
+										instancePath: instancePath + "/format",
+										schemaPath: "#/properties/format/minLength",
+										keyword: "minLength",
+										params: { limit: 1 },
+										message: "must NOT have fewer than 1 characters"
+									}];
+									return false;
+								}
+							} else {
+								validate18.errors = [{
+									instancePath: instancePath + "/format",
+									schemaPath: "#/properties/format/type",
+									keyword: "type",
+									params: { type: "string" },
+									message: "must be string"
+								}];
+								return false;
+							}
+						}
+						var valid0 = _errs2 === errors;
+					} else var valid0 = true;
+					if (valid0) {
+						if (data.version !== void 0) {
+							const _errs4 = errors;
+							if (1 !== data.version) {
+								validate18.errors = [{
+									instancePath: instancePath + "/version",
+									schemaPath: "#/properties/version/const",
+									keyword: "const",
+									params: { allowedValue: 1 },
+									message: "must be equal to constant"
+								}];
+								return false;
+							}
+							var valid0 = _errs4 === errors;
+						} else var valid0 = true;
+						if (valid0) {
+							if (data.settings !== void 0) {
+								const _errs5 = errors;
+								if (!validate17(data.settings, {
+									instancePath: instancePath + "/settings",
+									parentData: data,
+									parentDataProperty: "settings",
+									rootData
+								})) {
+									vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
+									errors = vErrors.length;
+								}
+								var valid0 = _errs5 === errors;
+							} else var valid0 = true;
+						}
+					}
+				}
+			}
+		} else {
+			validate18.errors = [{
+				instancePath,
+				schemaPath: "#/type",
+				keyword: "type",
+				params: { type: "object" },
+				message: "must be object"
+			}];
+			return false;
+		}
+	}
+	validate18.errors = vErrors;
+	return errors === 0;
+}
+export { validateBrushPreset, validateBrushPresetFile, validateDocument, validateHistoryMessage, validatePaletteFile, validatePatchMessage, validateSettings, validateSettingsFile, validateStrokeMessage };