@lvl99dotcom/paintcanvas 0.3.1 → 0.5.0

package/dist/lib/palette/index.d.ts

@@ -0,0 +1,49 @@
+import { type PaletteFile } from "./schema";
+export * from "./schema";
+/** The colours a palette starts with */
+export declare const DEFAULT_PALETTE: readonly string[];
+/** Messages shown when importing or exporting a palette fails */
+export declare const PALETTE_FILE_ERRORS: {
+    readonly incompatible: "Colour palette JSON file not compatible";
+    readonly read: "Failed to read colour palette JSON file";
+};
+/** Importing a palette failed, with a message for the user */
+export declare class PaletteFileError extends Error {
+}
+/** Result of checking a palette file */
+export type PaletteValidationResult = {
+    valid: true;
+    value: PaletteFile;
+} | {
+    valid: false;
+    errors: string[];
+};
+/**
+ * Check a colour palette file against `paletteFileSchema`.
+ *
+ * @example
+ * isValidPaletteFile({ format: "paintcanvas-palette", version: 1, colours: ["#ff0000"] }).valid; // true
+ */
+export declare const isValidPaletteFile: (input: unknown) => PaletteValidationResult;
+/**
+ * The file name a palette is exported to on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+ *
+ * @example
+ * paletteFileName(new Date(2026, 10, 4)); // "paintcanvas-palette-2026-11-04.json"
+ */
+export declare const paletteFileName: (date?: Date, prefix?: string) => string;
+/**
+ * Write colours to a colour palette file (JSON) of a format (see `PaintCanvasNames.paletteFileFormat`).
+ *
+ * @example
+ * exportPaletteFile(["#ff0000"]); // '{ "format": "paintcanvas-palette", "version": 1, "colours": ["#ff0000"] }'
+ */
+export declare const exportPaletteFile: (colours: readonly string[], format?: string) => string;
+/**
+ * Read the colours (as lowercase `#rrggbb`) in a colour palette file of one of the given formats (PaintCanvas's by
+ * default). Throws a `PaletteFileError` if it isn't valid JSON or a compatible file.
+ *
+ * @example
+ * parsePaletteFile('{ "format": "paintcanvas-palette", "version": 1, "colours": ["#FF0000"] }'); // ["#ff0000"]
+ */
+export declare const parsePaletteFile: (text: string, formats?: readonly string[]) => string[];

package/dist/lib/palette/index.js

@@ -0,0 +1,82 @@
+import { formatErrors } from "../presets/index.js";
+import { validatePaletteFile } from "../validation/validators.generated.js";
+import { HEX_COLOUR_PATTERN, MAX_PALETTE_COLOURS, MAX_PALETTE_FILE_FORMAT_LENGTH, PALETTE_FILE_FORMAT, PALETTE_FILE_FORMATS, PALETTE_FILE_VERSION, paletteFileSchema } from "./schema.js";
+// src/lib/palette/index.ts
+/** The colours a palette starts with */
+var DEFAULT_PALETTE = [
+	"#2c6bff",
+	"#8f3de8",
+	"#f40f95",
+	"#fb234a",
+	"#fe7e07",
+	"#ffd52c",
+	"#6dc905",
+	"#21e887",
+	"#13c3f4",
+	"#000000",
+	"#333333",
+	"#666666",
+	"#999999",
+	"#cccccc",
+	"#ffffff"
+];
+/** Messages shown when importing or exporting a palette fails */
+var PALETTE_FILE_ERRORS = {
+	incompatible: "Colour palette JSON file not compatible",
+	read: "Failed to read colour palette JSON file"
+};
+/** Importing a palette failed, with a message for the user */
+var PaletteFileError = class extends Error {};
+/**
+* Check a colour palette file against `paletteFileSchema`.
+*
+* @example
+* isValidPaletteFile({ format: "paintcanvas-palette", version: 1, colours: ["#ff0000"] }).valid; // true
+*/
+var isValidPaletteFile = (input) => validatePaletteFile(input) ? {
+	valid: true,
+	value: input
+} : {
+	valid: false,
+	errors: formatErrors(validatePaletteFile.errors)
+};
+/**
+* The file name a palette is exported to on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+*
+* @example
+* paletteFileName(new Date(2026, 10, 4)); // "paintcanvas-palette-2026-11-04.json"
+*/
+var paletteFileName = (date = /* @__PURE__ */ new Date(), prefix = "paintcanvas") => {
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${prefix}-palette-${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}.json`;
+};
+/**
+* Write colours to a colour palette file (JSON) of a format (see `PaintCanvasNames.paletteFileFormat`).
+*
+* @example
+* exportPaletteFile(["#ff0000"]); // '{ "format": "paintcanvas-palette", "version": 1, "colours": ["#ff0000"] }'
+*/
+var exportPaletteFile = (colours, format = PALETTE_FILE_FORMAT) => JSON.stringify({
+	format,
+	version: 1,
+	colours
+}, null, 2);
+/**
+* Read the colours (as lowercase `#rrggbb`) in a colour palette file of one of the given formats (PaintCanvas's by
+* default). Throws a `PaletteFileError` if it isn't valid JSON or a compatible file.
+*
+* @example
+* parsePaletteFile('{ "format": "paintcanvas-palette", "version": 1, "colours": ["#FF0000"] }'); // ["#ff0000"]
+*/
+var parsePaletteFile = (text, formats = PALETTE_FILE_FORMATS) => {
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		throw new PaletteFileError(PALETTE_FILE_ERRORS.incompatible);
+	}
+	const result = isValidPaletteFile(data);
+	if (!result.valid || !formats.includes(result.value.format)) throw new PaletteFileError(PALETTE_FILE_ERRORS.incompatible);
+	return result.value.colours.map((colour) => colour.toLowerCase());
+};
+export { DEFAULT_PALETTE, HEX_COLOUR_PATTERN, MAX_PALETTE_COLOURS, MAX_PALETTE_FILE_FORMAT_LENGTH, PALETTE_FILE_ERRORS, PALETTE_FILE_FORMAT, PALETTE_FILE_FORMATS, PALETTE_FILE_VERSION, PaletteFileError, exportPaletteFile, isValidPaletteFile, paletteFileName, paletteFileSchema, parsePaletteFile };

package/dist/lib/palette/schema.d.ts

@@ -0,0 +1,45 @@
+/** The `format` of a colour palette file, unless the implementer names their own (see `PaintCanvasNames`) */
+export declare const PALETTE_FILE_FORMAT = "paintcanvas-palette";
+/** Formats of colour palette files that are imported by default */
+export declare const PALETTE_FILE_FORMATS: readonly string[];
+/** The version of the colour palette file format */
+export declare const PALETTE_FILE_VERSION = 1;
+/** Most colours in a palette (and in one file) */
+export declare const MAX_PALETTE_COLOURS = 1000;
+/** Longest palette file format name (characters) */
+export declare const MAX_PALETTE_FILE_FORMAT_LENGTH = 100;
+/** Matches a `#rrggbb` colour in any case */
+export declare const HEX_COLOUR_PATTERN = "^#[0-9a-fA-F]{6}$";
+/** A colour palette file: what users export and import */
+export interface PaletteFile {
+    /** Names the app or kind of file, e.g. `PALETTE_FILE_FORMAT` */
+    format: string;
+    version: typeof PALETTE_FILE_VERSION;
+    /** Colours as `#rrggbb`, in palette order */
+    colours: string[];
+}
+/** Schema of a colour palette file */
+export declare const paletteFileSchema: {
+    readonly $id: "paintcanvas/palette-file";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["format", "version", "colours"];
+    readonly properties: {
+        readonly format: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 100;
+        };
+        readonly version: {
+            readonly const: 1;
+        };
+        readonly colours: {
+            readonly type: "array";
+            readonly maxItems: 1000;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^#[0-9a-fA-F]{6}$";
+            };
+        };
+    };
+};

package/dist/lib/palette/schema.js

@@ -0,0 +1,41 @@
+// src/lib/palette/schema.ts
+/** The `format` of a colour palette file, unless the implementer names their own (see `PaintCanvasNames`) */
+var PALETTE_FILE_FORMAT = "paintcanvas-palette";
+/** Formats of colour palette files that are imported by default */
+var PALETTE_FILE_FORMATS = [PALETTE_FILE_FORMAT];
+/** The version of the colour palette file format */
+var PALETTE_FILE_VERSION = 1;
+/** Most colours in a palette (and in one file) */
+var MAX_PALETTE_COLOURS = 1e3;
+/** Longest palette file format name (characters) */
+var MAX_PALETTE_FILE_FORMAT_LENGTH = 100;
+/** Matches a `#rrggbb` colour in any case */
+var HEX_COLOUR_PATTERN = "^#[0-9a-fA-F]{6}$";
+/** Schema of a colour palette file */
+var paletteFileSchema = {
+	$id: "paintcanvas/palette-file",
+	type: "object",
+	additionalProperties: false,
+	required: [
+		"format",
+		"version",
+		"colours"
+	],
+	properties: {
+		format: {
+			type: "string",
+			minLength: 1,
+			maxLength: 100
+		},
+		version: { const: 1 },
+		colours: {
+			type: "array",
+			maxItems: MAX_PALETTE_COLOURS,
+			items: {
+				type: "string",
+				pattern: HEX_COLOUR_PATTERN
+			}
+		}
+	}
+};
+export { HEX_COLOUR_PATTERN, MAX_PALETTE_COLOURS, MAX_PALETTE_FILE_FORMAT_LENGTH, PALETTE_FILE_FORMAT, PALETTE_FILE_FORMATS, PALETTE_FILE_VERSION, paletteFileSchema };

package/dist/lib/rendering/cursors/index.d.ts

@@ -8,6 +8,8 @@
  * svgCursor("M4 4 L20 20", [4, 4], "crosshair"); // 'url("data:image/svg+xml,...") 4 4, crosshair'
  */
 export declare const svgCursor: (path: string, hotspot: [number, number], fallback: string) => string;
+/** Deleting: an "X", e.g. over a brush preset or saved colour that a click deletes (Alt/Option held); the point is its middle */
+export declare const DELETE_CURSOR: string;
 /** Colour sample (eyedropper): a pipette pointing down to the left; the point is at its tip */
 export declare const EYEDROPPER_CURSOR: string;
 /** Polygon lasso: a straight-edged loop with a tail; the point is at the tail's end */

package/dist/lib/rendering/cursors/index.js

@@ -12,6 +12,8 @@ var svgCursor = (path, hotspot, fallback) => {
 	const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="${path}" stroke="#ffffff" stroke-width="3.5"/><path d="${path}" stroke="#000000" stroke-width="1.5"/></svg>`;
 	return `url("data:image/svg+xml,${encodeURIComponent(svg)}") ${hotspot[0]} ${hotspot[1]}, ${fallback}`;
 };
+/** Deleting: an "X", e.g. over a brush preset or saved colour that a click deletes (Alt/Option held); the point is its middle */
+var DELETE_CURSOR = svgCursor("M6 6 L18 18 M18 6 L6 18", [12, 12], "not-allowed");
 /** Colour sample (eyedropper): a pipette pointing down to the left; the point is at its tip */
 var EYEDROPPER_CURSOR = svgCursor("M2 22 L3 18 L12 9 L15 12 L6 21 Z M10 7 L17 14 M14 10 L18 6 C19 5 20 4 21 5 C22 6 21 7 20 8 L16 12", [2, 22], "crosshair");
 /** Polygon lasso: a straight-edged loop with a tail; the point is at the tail's end */
@@ -20,4 +22,4 @@ var POLYGON_LASSO_CURSOR = svgCursor("M3 21 L7 15 M7 15 L5 6 L13 2 L21 7 L17 15
 var FREEFORM_LASSO_CURSOR = svgCursor("M3 21 C3 19 5 18 7 17 C7 17 5 16 4 14 C2 10 4 6 8 5 C11 4 12 6 15 4 C18 3 22 6 20 10 C19 13 21 15 18 16 C15 17 11 15 9 16 C8 16.5 7.5 17 7 17", [3, 21], "crosshair");
 /** Rotate: the browser's grab cursor, as browsers have no standard rotate cursor */
 var ROTATE_CURSOR = "grab";
-export { EYEDROPPER_CURSOR, FREEFORM_LASSO_CURSOR, POLYGON_LASSO_CURSOR, ROTATE_CURSOR, svgCursor };
+export { DELETE_CURSOR, EYEDROPPER_CURSOR, FREEFORM_LASSO_CURSOR, POLYGON_LASSO_CURSOR, ROTATE_CURSOR, svgCursor };

package/dist/lib/rendering/sample/index.js

@@ -1,3 +1,4 @@
+import { rgbToHex } from "../../utils/colour/index.js";
 import { CANVAS_BACKGROUND, drawLayers } from "../compositing/index.js";
 // src/lib/rendering/sample/index.ts
 /** How many canvas pixels across the sampling window enlarges */
@@ -12,11 +13,11 @@ var PREVIEW_MAX_PIXELS = 100;
 * @example
 * toHex(255, 0, 128); // "#ff0080"
 */
-var toHex = (r, g, b) => `#${[
+var toHex = (r, g, b) => rgbToHex({
 	r,
 	g,
 	b
-].map((c) => Math.round(c).toString(16).padStart(2, "0")).join("")}`;
+});
 /**
 * The average colour of RGBA pixels, counting every pixel that isn't fully transparent (transparent pixels are outside
 * the canvas). Undefined if all are transparent.

package/dist/lib/settings/index.d.ts

@@ -0,0 +1,63 @@
+import type PaintCanvas from "../classes/PaintCanvas";
+import { type AppSettings } from "./schema";
+export * from "./schema";
+/** Messages shown when importing settings fails */
+export declare const SETTINGS_FILE_ERRORS: {
+    readonly incompatible: "Settings JSON file not compatible";
+    readonly read: "Failed to read settings JSON file";
+};
+/** Importing settings failed, with a message for the user */
+export declare class SettingsFileError extends Error {
+}
+/** Result of checking settings */
+export type SettingsValidationResult = {
+    valid: true;
+    value: AppSettings;
+} | {
+    valid: false;
+    errors: string[];
+};
+/**
+ * Check app settings (e.g. kept in the browser) against `settingsSchema`.
+ *
+ * @example
+ * isValidSettings({ palette: ["#ff0000"] }).valid; // true
+ */
+export declare const isValidSettings: (input: unknown) => SettingsValidationResult;
+/**
+ * The app settings of a canvas: its input settings, keyboard shortcuts, colour palette, colours, theme and language.
+ *
+ * @example
+ * collectSettings(canvas).palette; // ["#2c6bff", ...]
+ */
+export declare const collectSettings: (app: PaintCanvas) => AppSettings;
+/**
+ * Use app settings on a canvas, e.g. ones kept in the browser or imported. Parts left out stay as they are; invalid
+ * values within a part are left out (see each part's sanitising).
+ *
+ * @example
+ * applySettings(canvas, { colours: { foreground: "#ff0000", background: "#ffffff" } });
+ */
+export declare const applySettings: (app: PaintCanvas, settings: AppSettings) => void;
+/**
+ * The file name settings are exported to on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+ *
+ * @example
+ * settingsFileName(new Date(2026, 10, 4)); // "paintcanvas-settings-2026-11-04.json"
+ */
+export declare const settingsFileName: (date?: Date, prefix?: string) => string;
+/**
+ * Write app settings to a settings file (JSON) of a format (see `PaintCanvasNames.settingsFileFormat`).
+ *
+ * @example
+ * exportSettingsFile(collectSettings(canvas)); // '{ "format": "paintcanvas-settings", "version": 1, "settings": {...} }'
+ */
+export declare const exportSettingsFile: (settings: AppSettings, format?: string) => string;
+/**
+ * Read the app settings in a settings file of one of the given formats (PaintCanvas's by default). Throws a
+ * `SettingsFileError` if it isn't valid JSON or a compatible file.
+ *
+ * @example
+ * applySettings(canvas, parseSettingsFile(text));
+ */
+export declare const parseSettingsFile: (text: string, formats?: readonly string[]) => AppSettings;

package/dist/lib/settings/index.js

@@ -0,0 +1,93 @@
+import { formatErrors } from "../presets/index.js";
+import { validateSettings, validateSettingsFile } from "../validation/validators.generated.js";
+import { MAX_SAVED_SHORTCUTS, MAX_SETTINGS_FILE_FORMAT_LENGTH, SETTINGS_FILE_FORMAT, SETTINGS_FILE_FORMATS, SETTINGS_FILE_VERSION, keyComboSchema, settingsFileSchema, settingsSchema } from "./schema.js";
+// src/lib/settings/index.ts
+/** Messages shown when importing settings fails */
+var SETTINGS_FILE_ERRORS = {
+	incompatible: "Settings JSON file not compatible",
+	read: "Failed to read settings JSON file"
+};
+/** Importing settings failed, with a message for the user */
+var SettingsFileError = class extends Error {};
+/**
+* Check app settings (e.g. kept in the browser) against `settingsSchema`.
+*
+* @example
+* isValidSettings({ palette: ["#ff0000"] }).valid; // true
+*/
+var isValidSettings = (input) => validateSettings(input) ? {
+	valid: true,
+	value: input
+} : {
+	valid: false,
+	errors: formatErrors(validateSettings.errors)
+};
+/**
+* The app settings of a canvas: its input settings, keyboard shortcuts, colour palette, colours, theme and language.
+*
+* @example
+* collectSettings(canvas).palette; // ["#2c6bff", ...]
+*/
+var collectSettings = (app) => ({
+	input: structuredClone(app.input.data),
+	shortcuts: structuredClone(app.shortcuts.bindings),
+	palette: [...app.palette.colours],
+	colours: { ...app.colours },
+	ui: { ...app.ui.data }
+});
+/**
+* Use app settings on a canvas, e.g. ones kept in the browser or imported. Parts left out stay as they are; invalid
+* values within a part are left out (see each part's sanitising).
+*
+* @example
+* applySettings(canvas, { colours: { foreground: "#ff0000", background: "#ffffff" } });
+*/
+var applySettings = (app, settings) => {
+	if (settings.input) app.input.update(settings.input);
+	if (settings.shortcuts) app.shortcuts.load(settings.shortcuts);
+	if (settings.palette) app.palette.set(settings.palette);
+	if (settings.colours) {
+		app.setColour(settings.colours.foreground, "foreground");
+		app.setColour(settings.colours.background, "background");
+	}
+	if (settings.ui) app.ui.update(settings.ui);
+};
+/**
+* The file name settings are exported to on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+*
+* @example
+* settingsFileName(new Date(2026, 10, 4)); // "paintcanvas-settings-2026-11-04.json"
+*/
+var settingsFileName = (date = /* @__PURE__ */ new Date(), prefix = "paintcanvas") => {
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${prefix}-settings-${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}.json`;
+};
+/**
+* Write app settings to a settings file (JSON) of a format (see `PaintCanvasNames.settingsFileFormat`).
+*
+* @example
+* exportSettingsFile(collectSettings(canvas)); // '{ "format": "paintcanvas-settings", "version": 1, "settings": {...} }'
+*/
+var exportSettingsFile = (settings, format = SETTINGS_FILE_FORMAT) => JSON.stringify({
+	format,
+	version: 1,
+	settings
+}, null, 2);
+/**
+* Read the app settings in a settings file of one of the given formats (PaintCanvas's by default). Throws a
+* `SettingsFileError` if it isn't valid JSON or a compatible file.
+*
+* @example
+* applySettings(canvas, parseSettingsFile(text));
+*/
+var parseSettingsFile = (text, formats = SETTINGS_FILE_FORMATS) => {
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		throw new SettingsFileError(SETTINGS_FILE_ERRORS.incompatible);
+	}
+	if (!validateSettingsFile(data) || !formats.includes(data.format)) throw new SettingsFileError(SETTINGS_FILE_ERRORS.incompatible);
+	return data.settings;
+};
+export { MAX_SAVED_SHORTCUTS, MAX_SETTINGS_FILE_FORMAT_LENGTH, SETTINGS_FILE_ERRORS, SETTINGS_FILE_FORMAT, SETTINGS_FILE_FORMATS, SETTINGS_FILE_VERSION, SettingsFileError, applySettings, collectSettings, exportSettingsFile, isValidSettings, keyComboSchema, parseSettingsFile, settingsFileName, settingsFileSchema, settingsSchema };

package/dist/lib/settings/schema.d.ts

@@ -0,0 +1,168 @@
+import type { InputSettingsData } from "../classes/InputSettings";
+import { type UiSettingsData } from "../classes/UiSettings/index.ts";
+import type { KeyCombo } from "../utils/shortcuts";
+/** The `format` of a settings file, unless the implementer names their own (see `PaintCanvasNames`) */
+export declare const SETTINGS_FILE_FORMAT = "paintcanvas-settings";
+/** Formats of settings files that are imported by default */
+export declare const SETTINGS_FILE_FORMATS: readonly string[];
+/** The version of the settings file format */
+export declare const SETTINGS_FILE_VERSION = 1;
+/** Longest settings file format name (characters) */
+export declare const MAX_SETTINGS_FILE_FORMAT_LENGTH = 100;
+/** Most keyboard shortcuts in saved settings */
+export declare const MAX_SAVED_SHORTCUTS = 200;
+/** The user's app settings. Each part is optional, so a file can hold only some of them. */
+export interface AppSettings {
+    /** How input devices control the canvas */
+    input?: Partial<InputSettingsData>;
+    /** Each configurable keyboard shortcut action's key combination, by ID (null when it has none) */
+    shortcuts?: Record<string, KeyCombo | null>;
+    /** The colour palette's colours, as `#rrggbb` */
+    palette?: string[];
+    /** The foreground and background colours, as `#rrggbb` */
+    colours?: {
+        foreground: string;
+        background: string;
+    };
+    /** The theme and language */
+    ui?: Partial<UiSettingsData>;
+}
+/** A settings file: what users export and import */
+export interface SettingsFile {
+    /** Names the app or kind of file, e.g. `SETTINGS_FILE_FORMAT` */
+    format: string;
+    version: typeof SETTINGS_FILE_VERSION;
+    settings: AppSettings;
+}
+/** Schema of a key combination */
+export declare const keyComboSchema: {
+    readonly $id: "paintcanvas/key-combo";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["key"];
+    readonly properties: {
+        readonly key: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 32;
+        };
+        readonly cmd: {
+            readonly type: "boolean";
+        };
+        readonly ctrl: {
+            readonly type: "boolean";
+        };
+        readonly shift: {
+            readonly type: "boolean";
+        };
+        readonly alt: {
+            readonly type: "boolean";
+        };
+    };
+};
+/** Schema of the user's app settings */
+export declare const settingsSchema: {
+    readonly $id: "paintcanvas/settings";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly input: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly scrollPan: {
+                    readonly type: "boolean";
+                };
+                readonly pinchZoom: {
+                    readonly type: "boolean";
+                };
+                readonly modifierScrollZoom: {
+                    readonly type: "boolean";
+                };
+                readonly focusPen: {
+                    readonly type: "boolean";
+                };
+                readonly gestures: {
+                    readonly type: "object";
+                    readonly maxProperties: 20;
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                        readonly maxLength: 50;
+                    };
+                };
+            };
+        };
+        readonly shortcuts: {
+            readonly type: "object";
+            readonly maxProperties: 200;
+            readonly propertyNames: {
+                readonly maxLength: 64;
+            };
+            readonly additionalProperties: {
+                readonly anyOf: readonly [{
+                    readonly type: "null";
+                }, {
+                    readonly $ref: "key-combo";
+                }];
+            };
+        };
+        readonly palette: {
+            readonly type: "array";
+            readonly maxItems: 1000;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^#[0-9a-fA-F]{6}$";
+            };
+        };
+        readonly colours: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["foreground", "background"];
+            readonly properties: {
+                readonly foreground: {
+                    readonly type: "string";
+                    readonly pattern: "^#[0-9a-fA-F]{6}$";
+                };
+                readonly background: {
+                    readonly type: "string";
+                    readonly pattern: "^#[0-9a-fA-F]{6}$";
+                };
+            };
+        };
+        readonly ui: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly theme: {
+                    readonly enum: readonly ["light", "dark", "system"];
+                };
+                readonly locale: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 35;
+                    readonly pattern: "^[A-Za-z0-9-]+$";
+                };
+            };
+        };
+    };
+};
+/** Schema of a settings file */
+export declare const settingsFileSchema: {
+    readonly $id: "paintcanvas/settings-file";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["format", "version", "settings"];
+    readonly properties: {
+        readonly format: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 100;
+        };
+        readonly version: {
+            readonly const: 1;
+        };
+        readonly settings: {
+            readonly $ref: "settings";
+        };
+    };
+};