@cssints/tui 0.0.0-stage → 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,49 @@
+import { TuiProps, TuiProps as TuiProps$1, TuiShape, TuiShape as TuiShape$1 } from "cssints/tui";
+//#region src/index.d.ts
+/** The states a renderable is in. */
+export interface TuiState {
+  hover?: boolean;
+  focus?: boolean;
+  active?: boolean;
+}
+/**
+ * The theme in use.
+ *
+ * @returns {string} a name of `createGlobalTheme(tokens, name, ...)`, `""` for the default values
+ */
+export declare const theme: () => string;
+/**
+ * Swaps the theme of every renderable an adapter has attached: their props are resolved again.
+ *
+ * @param {string} name a name of `createGlobalTheme(tokens, name, ...)`, `""` for the default values
+ */
+export declare const setTheme: (name: string) => void;
+/**
+ * Registers (or replaces) a theme of the run-time table: the value of each token, by name (`color-bg` for `var(--color-bg)`), laid over
+ * the static theme `base` (`""`: the default values) for every prop a site set to that token. A token it leaves out
+ * keeps the value of `base`. When `name` is the theme in use, every attached renderable is resolved again.
+ *
+ * @param {string} name the theme, for `setTheme(name)`
+ * @param {Record<string, string>} values a colour (`#rrggbb`, `ansi:N` or `default`) per token name
+ * @param {string} base a name of `createGlobalTheme(tokens, name, ...)`, `""` for the default values
+ */
+export declare const defineTheme: (name: string, values: Record<string, string>, base?: string) => void;
+/**
+ * Calls `fn` on every theme change.
+ *
+ * @param {Function} fn called with the name of the new theme
+ * @returns {Function} the function that stops it
+ */
+export declare const onTheme: (fn: (name: string) => void) => (() => void);
+/**
+ * The props of `style` in `state` and theme `name` (default: the one in use): the props, then what the theme changes,
+ * then the `:hover`, `:focus` and `:active` overlays that are on, in that order, each with the theme's.
+ *
+ * @param {TuiShape} style a style of cssints/tui
+ * @param {TuiState} state the states that are on
+ * @param {string} name the theme
+ * @returns {TuiProps} the props, renderer-neutral
+ */
+export declare const resolve: (style: TuiShape$1, state?: TuiState, name?: string) => TuiProps$1;
+//#endregion
+export type { TuiProps, TuiShape };

package/dist/index.mjs

@@ -0,0 +1,88 @@
+//#region src/index.ts
+const STATES = [
+	":hover",
+	":focus",
+	":active"
+];
+const own = (out, layer) => {
+	if (layer) {
+		for (const [k, v] of Object.entries(layer)) if (k !== "themes" && k !== "vars" && !k.startsWith(":")) out[k] = v;
+	}
+};
+let current = "";
+const listeners = /* @__PURE__ */ new Set();
+const table = /* @__PURE__ */ new Map();
+/**
+* The theme in use.
+*
+* @returns {string} a name of `createGlobalTheme(tokens, name, ...)`, `""` for the default values
+*/
+const theme = () => current;
+/**
+* Swaps the theme of every renderable an adapter has attached: their props are resolved again.
+*
+* @param {string} name a name of `createGlobalTheme(tokens, name, ...)`, `""` for the default values
+*/
+const setTheme = (name) => {
+	if (name === current) return;
+	current = name;
+	for (const l of listeners) l(name);
+};
+/**
+* Registers (or replaces) a theme of the run-time table: the value of each token, by name (`color-bg` for `var(--color-bg)`), laid over
+* the static theme `base` (`""`: the default values) for every prop a site set to that token. A token it leaves out
+* keeps the value of `base`. When `name` is the theme in use, every attached renderable is resolved again.
+*
+* @param {string} name the theme, for `setTheme(name)`
+* @param {Record<string, string>} values a colour (`#rrggbb`, `ansi:N` or `default`) per token name
+* @param {string} base a name of `createGlobalTheme(tokens, name, ...)`, `""` for the default values
+*/
+const defineTheme = (name, values, base = "") => {
+	table.set(name, {
+		values,
+		base
+	});
+	if (name === current) for (const l of listeners) l(name);
+};
+/**
+* Calls `fn` on every theme change.
+*
+* @param {Function} fn called with the name of the new theme
+* @returns {Function} the function that stops it
+*/
+const onTheme = (fn) => {
+	listeners.add(fn);
+	return () => listeners.delete(fn);
+};
+/**
+* The props of `style` in `state` and theme `name` (default: the one in use): the props, then what the theme changes,
+* then the `:hover`, `:focus` and `:active` overlays that are on, in that order, each with the theme's.
+*
+* @param {TuiShape} style a style of cssints/tui
+* @param {TuiState} state the states that are on
+* @param {string} name the theme
+* @returns {TuiProps} the props, renderer-neutral
+*/
+const resolve = (style, state = {}, name = current) => {
+	const run = table.get(name);
+	const base = run ? run.base : name;
+	const themed = base ? style.themes?.[base] : void 0;
+	const vars = style.vars;
+	const out = {};
+	const tokens = (layer) => {
+		if (run && layer) {
+			for (const [k, v] of Object.entries(layer)) if (typeof v === "string" && Object.hasOwn(run.values, v)) out[k] = run.values[v];
+		}
+	};
+	own(out, style);
+	own(out, themed);
+	tokens(vars);
+	for (const s of STATES) if (state[s === ":hover" ? "hover" : s === ":focus" ? "focus" : "active"]) {
+		own(out, style[s]);
+		own(out, themed?.[s]);
+		tokens(vars?.[s]);
+	}
+	return out;
+};
+//#endregion
+export { defineTheme, onTheme, resolve, setTheme, theme };

package/dist/opentui.d.mts

@@ -0,0 +1,66 @@
+import { TuiState, resolve, setTheme, theme } from "./index.mjs";
+import { c as Report, g as SystemTheme } from "./system-CFyJGOUM.mjs";
+import { CliRenderer, Renderable, TerminalColors, TextNodeRenderable, ThemeMode } from "@opentui/core";
+import { TuiProps, TuiShape } from "cssints/tui";
+//#region src/opentui-system.d.ts
+/**
+ * The report of OpenTUI's palette and theme mode.
+ *
+ * @param {TerminalColors} colors what `renderer.getPalette()` gave (none yet: `undefined`)
+ * @param {ThemeMode} mode `renderer.themeMode`
+ * @returns {Report} the report for `theme.solve`
+ */
+export declare const reportOf: (colors: TerminalColors | undefined, mode: ThemeMode | null) => Report;
+/**
+ * Follows the terminal's colours: sets the system theme (`setTheme`) with the fallback at once, asks OpenTUI for the
+ * palette, and rebuilds the theme when it comes, on a `palette` event and on a `theme_mode` change.
+ *
+ * @param {CliRenderer} renderer the renderer
+ * @param {SystemTheme} theme the theme of `createSystemTheme`
+ * @param {object} options `wait`: how long to wait for the palette, in ms (default 100)
+ * @returns {Promise<Function>} after the palette or `wait`, whichever is first: the function that stops following
+ */
+export declare const followSystemTheme: (renderer: CliRenderer, theme: SystemTheme, options?: {
+  wait?: number;
+}) => Promise<() => void>;
+//#endregion
+//#region src/opentui.d.ts
+/**
+ * The OpenTUI props of a style (`has` tells which props the renderable has: a box takes `backgroundColor`, a text `bg`):
+ * `color` is `fg` (`textColor` on an editable or a select), the text attributes are the bits of `attributes`, the
+ * caret is `cursorStyle` and `cursorColor` (Input, Textarea). `cursor` is not a prop: `attach` sets the mouse pointer.
+ *
+ * @param {TuiProps} p the props of `resolve()`
+ * @param {Function} has whether the renderable has a prop
+ * @returns {Record<string, unknown>} the props of an OpenTUI renderable
+ */
+export declare const props: (p: TuiProps, has?: (key: string) => boolean) => Record<string, unknown>;
+type Node = Renderable | TextNodeRenderable;
+/**
+ * Sets the props of `style` on `r` and keeps them up to date: `:hover` from `over` to `out`, `:active` from `down` to
+ * `up` (or `out`), `:focus` while it has focus (a box needs `focusable: true`), and the theme of `setTheme`. The mouse
+ * pointer is the style's `cursor` on `over`, `default` again on `out`. Handlers of your own (`onMouseOver`) still run.
+ * A focused renderable draws its `focused*` colours (`focusedBorderColor` of a box): they follow the style too. A text
+ * node (`<span>`, `<a>`) has no mouse events and no focus: it takes the props and the theme, not the states.
+ * On a renderable it has attached already, it swaps the style (cssints-332g): the states, the theme and the hooks stay,
+ * a prop only the old style set goes back to the renderable's own value, and the pointer follows the new `cursor`.
+ *
+ * @param {Renderable | TextNodeRenderable} r a renderable or a text node of OpenTUI
+ * @param {TuiShape} style a style of cssints/tui
+ * @returns {Renderable | TextNodeRenderable} `r`
+ */
+export declare const attach: <R extends Node>(r: R, style: TuiShape) => R;
+/**
+ * Props to spread on an OpenTUI element of Solid or React: `<box {...use(card)} />`. The `ref` attaches the style
+ * (`attach`) when the renderable is made, before its first frame. A style that changes is an accessor,
+ * `use(() => (active() ? a : b))`: Solid calls a ref in a render effect, so the signals it reads run it again, and each
+ * run swaps the style (React calls the new ref of each render). The adapter imports no framework.
+ *
+ * @param {TuiShape | Function} style a style of cssints/tui, or a function that returns one
+ * @returns {object} `{ ref }`
+ */
+export declare const use: (style: TuiShape | (() => TuiShape)) => {
+  ref: (r: Node | null) => void;
+};
+//#endregion
+export { type TuiState, resolve, setTheme, theme };

package/dist/opentui.mjs

@@ -0,0 +1,209 @@
+import { onTheme, resolve, setTheme, theme } from "./index.mjs";
+import { RGBA } from "@opentui/core";
+//#region src/opentui-system.ts
+/**
+* The report of OpenTUI's palette and theme mode.
+*
+* @param {TerminalColors} colors what `renderer.getPalette()` gave (none yet: `undefined`)
+* @param {ThemeMode} mode `renderer.themeMode`
+* @returns {Report} the report for `theme.solve`
+*/
+const reportOf = (colors, mode) => ({
+	fg: colors?.defaultForeground,
+	bg: colors?.defaultBackground,
+	ansi: colors?.palette ?? [],
+	scheme: mode
+});
+/**
+* Follows the terminal's colours: sets the system theme (`setTheme`) with the fallback at once, asks OpenTUI for the
+* palette, and rebuilds the theme when it comes, on a `palette` event and on a `theme_mode` change.
+*
+* @param {CliRenderer} renderer the renderer
+* @param {SystemTheme} theme the theme of `createSystemTheme`
+* @param {object} options `wait`: how long to wait for the palette, in ms (default 100)
+* @returns {Promise<Function>} after the palette or `wait`, whichever is first: the function that stops following
+*/
+const followSystemTheme = async (renderer, theme, options = {}) => {
+	let colors;
+	const apply = () => theme.apply(reportOf(colors, renderer.themeMode), { indexed: true });
+	const onPalette = (c) => {
+		colors = c;
+		apply();
+	};
+	const query = () => renderer.getPalette({ size: 16 }).then(onPalette, () => {});
+	const onMode = () => {
+		apply();
+		query();
+	};
+	renderer.on("palette", onPalette);
+	renderer.on("theme_mode", onMode);
+	const stop = () => {
+		renderer.off("palette", onPalette);
+		renderer.off("theme_mode", onMode);
+	};
+	renderer.once("destroy", stop);
+	apply();
+	setTheme(theme.name);
+	const waited = Promise.withResolvers();
+	const timer = setTimeout(waited.resolve, options.wait ?? 100);
+	await Promise.race([query(), waited.promise]);
+	clearTimeout(timer);
+	return stop;
+};
+//#endregion
+//#region src/opentui.ts
+const BITS = {
+	bold: 1,
+	dim: 2,
+	italic: 4,
+	underline: 8,
+	strikethrough: 128
+};
+const SHAPE = {
+	auto: "default",
+	bar: "line",
+	block: "block",
+	underscore: "underline"
+};
+const FOCUSED = [
+	["borderColor", "focusedBorderColor"],
+	["backgroundColor", "focusedBackgroundColor"],
+	["textColor", "focusedTextColor"]
+];
+const drawn = (v, bg) => v === "default" ? bg ? RGBA.defaultBackground() : RGBA.defaultForeground() : typeof v === "string" && v.startsWith("ansi:") ? RGBA.fromIndex(Number(v.slice(5))) : v;
+/**
+* The OpenTUI props of a style (`has` tells which props the renderable has: a box takes `backgroundColor`, a text `bg`):
+* `color` is `fg` (`textColor` on an editable or a select), the text attributes are the bits of `attributes`, the
+* caret is `cursorStyle` and `cursorColor` (Input, Textarea). `cursor` is not a prop: `attach` sets the mouse pointer.
+*
+* @param {TuiProps} p the props of `resolve()`
+* @param {Function} has whether the renderable has a prop
+* @returns {Record<string, unknown>} the props of an OpenTUI renderable
+*/
+const props = (p, has = () => true) => {
+	const out = {};
+	let bits;
+	for (const [k, v] of Object.entries(p)) if (Object.hasOwn(BITS, k)) bits = (bits ?? 0) | (v ? BITS[k] : 0);
+	else if (k === "color") out[has("fg") || !has("textColor") ? "fg" : "textColor"] = drawn(v, false);
+	else if (k === "backgroundColor") out[has("backgroundColor") ? "backgroundColor" : "bg"] = drawn(v, true);
+	else if (k === "caretColor") out.cursorColor = drawn(v, false);
+	else if (k === "borderColor") out.borderColor = drawn(v, false);
+	else if (k !== "cursor" && k !== "caretShape" && k !== "caretAnimation") out[k] = v;
+	if (bits !== void 0) out.attributes = bits;
+	if (p.caretShape || p.caretAnimation) out.cursorStyle = {
+		style: SHAPE[p.caretShape ?? "auto"],
+		blinking: p.caretAnimation !== "manual"
+	};
+	return out;
+};
+const attached = /* @__PURE__ */ new WeakMap();
+/**
+* Sets the props of `style` on `r` and keeps them up to date: `:hover` from `over` to `out`, `:active` from `down` to
+* `up` (or `out`), `:focus` while it has focus (a box needs `focusable: true`), and the theme of `setTheme`. The mouse
+* pointer is the style's `cursor` on `over`, `default` again on `out`. Handlers of your own (`onMouseOver`) still run.
+* A focused renderable draws its `focused*` colours (`focusedBorderColor` of a box): they follow the style too. A text
+* node (`<span>`, `<a>`) has no mouse events and no focus: it takes the props and the theme, not the states.
+* On a renderable it has attached already, it swaps the style (cssints-332g): the states, the theme and the hooks stay,
+* a prop only the old style set goes back to the renderable's own value, and the pointer follows the new `cursor`.
+*
+* @param {Renderable | TextNodeRenderable} r a renderable or a text node of OpenTUI
+* @param {TuiShape} style a style of cssints/tui
+* @returns {Renderable | TextNodeRenderable} `r`
+*/
+const attach = (r, style) => {
+	const again = attached.get(r);
+	if (again) {
+		again(style);
+		return r;
+	}
+	const state = {};
+	const target = r;
+	const saved = /* @__PURE__ */ new Map();
+	const last = /* @__PURE__ */ new Map();
+	let pointer = false;
+	const apply = () => {
+		const next = props(resolve(style, state), (k) => k in r);
+		for (const [from, to] of FOCUSED) if (Object.hasOwn(next, from)) next[to] = next[from];
+		const attrs = next.attributes;
+		for (const k of /* @__PURE__ */ new Set([...saved.keys(), ...Object.keys(next)])) {
+			if (!(k in r)) continue;
+			if (!saved.has(k)) saved.set(k, target[k]);
+			let v = Object.hasOwn(next, k) ? next[k] : saved.get(k);
+			if (k === "attributes" && attrs !== void 0) v = saved.get(k) & -144 | attrs;
+			if (last.get(k) === v) continue;
+			last.set(k, v);
+			target[k] = v;
+		}
+		r.requestRender();
+	};
+	const set = (key, on) => {
+		if (!!state[key] === on) return false;
+		state[key] = on;
+		return true;
+	};
+	const stop = onTheme(apply);
+	if (!("onMouseEvent" in r)) {
+		attached.set(r, (next) => {
+			style = next;
+			apply();
+		});
+		const end = r.destroyRecursively.bind(r);
+		r.destroyRecursively = () => {
+			stop();
+			for (const child of r.getChildren()) child.destroyRecursively();
+			end();
+		};
+		apply();
+		return r;
+	}
+	const hooked = r;
+	const own = hooked.onMouseEvent.bind(r);
+	hooked.onMouseEvent = (event) => {
+		let changed = false;
+		if (event.type === "over") {
+			changed = set("hover", true);
+			const cursor = resolve(style, {
+				...state,
+				hover: true
+			}).cursor;
+			if (cursor) hooked.ctx.setMousePointer(cursor);
+			pointer = !!cursor;
+		} else if (event.type === "out") {
+			changed = set("hover", false);
+			changed = set("active", false) || changed;
+			if (pointer) hooked.ctx.setMousePointer("default");
+			pointer = false;
+		} else if (event.type === "down") changed = set("active", true);
+		else if (event.type === "up") changed = set("active", false);
+		if (changed || pointer) apply();
+		own(event);
+	};
+	hooked.on("focused", () => set("focus", true) && apply());
+	hooked.on("blurred", () => set("focus", false) && apply());
+	hooked.once("destroyed", stop);
+	attached.set(r, (next) => {
+		style = next;
+		if (state.hover) {
+			const cursor = resolve(style, state).cursor;
+			if (cursor || pointer) hooked.ctx.setMousePointer(cursor ?? "default");
+			pointer = !!cursor;
+		}
+		apply();
+	});
+	apply();
+	return r;
+};
+/**
+* Props to spread on an OpenTUI element of Solid or React: `<box {...use(card)} />`. The `ref` attaches the style
+* (`attach`) when the renderable is made, before its first frame. A style that changes is an accessor,
+* `use(() => (active() ? a : b))`: Solid calls a ref in a render effect, so the signals it reads run it again, and each
+* run swaps the style (React calls the new ref of each render). The adapter imports no framework.
+*
+* @param {TuiShape | Function} style a style of cssints/tui, or a function that returns one
+* @returns {object} `{ ref }`
+*/
+const use = (style) => ({ ref: (r) => {
+	if (r) attach(r, typeof style === "function" ? style() : style);
+} });
+//#endregion
+export { attach, followSystemTheme, props, reportOf, resolve, setTheme, theme, use };

package/dist/system-CFyJGOUM.d.mts

@@ -0,0 +1,118 @@
+//#region src/system.d.ts
+/** The 16 ANSI colours, by their index. */
+declare const SLOTS: readonly ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "brightBlack", "brightRed", "brightGreen", "brightYellow", "brightBlue", "brightMagenta", "brightCyan", "brightWhite"];
+type Slot = (typeof SLOTS)[number];
+/** Where a role takes its hue: an ANSI colour, or the terminal's default foreground or background. */
+type Hue = Slot | "fg" | "bg";
+type Appearance = "dark" | "light";
+/** A colour token of `createTokens` (its text at run time: `var(--name)`). */
+type ColourToken = string | {
+  readonly "~token": "color";
+};
+/** A colour token as a role of the system theme. */
+interface Role {
+  /** The hue source (default `"fg"`, `"bg"` for a surface). */
+  hue?: Hue;
+  /** The tokens it sits on (each must have a role). */
+  on?: readonly ColourToken[];
+  /** The WCAG 2 ratio against each of `on`: the least for text, the exact one (to the first) for a surface. */
+  contrast?: number;
+  /** A background: placed at `contrast` from its first `on`, toward the foreground; the terminal's background without. */
+  surface?: boolean;
+  /** What the terminal draws when it reports nothing: an ANSI index, or its default colour. */
+  ansi?: number | "default";
+}
+/** The roles of a token set, in its shape: a role per colour token, any left out. */
+type Roles<T> = { [K in keyof T]?: T[K] extends ColourToken ? Role : T[K] extends {
+  readonly "~token": unknown;
+} ? never : Roles<T[K]>; };
+/** What a terminal reported: `#rrggbb` colours (`undefined` or `null`: no answer) and its colour scheme. */
+interface Report {
+  fg?: string | null;
+  bg?: string | null;
+  ansi?: readonly (string | null | undefined)[];
+  scheme?: Appearance | null;
+}
+interface SolveOptions {
+  /** Whether the renderer draws ANSI indices (`ansi:N`, `default`); without, a terminal that reports nothing keeps the static theme. */
+  indexed?: boolean;
+  /** The `COLORFGBG` variable (default: the environment's). */
+  colorfgbg?: string;
+}
+interface Solved {
+  appearance: Appearance;
+  /** A colour per token name (`color-bg` for `var(--color-bg)`). */
+  values: Record<string, string>;
+  /** The static theme under it: what a token without a role, or every token without a palette, keeps. */
+  base: string;
+}
+interface SystemOptions {
+  /** The theme's name for `setTheme` (default `"system"`). */
+  name?: string;
+  /** The app's own colour per slot, for what the terminal did not report (default: an xterm-like palette). */
+  hues?: Partial<Record<Hue, string>>;
+  /** The static theme under the system theme, per appearance (default `""`, the default values). */
+  themes?: Partial<Record<Appearance, string>>;
+}
+interface SystemTheme {
+  readonly name: string;
+  /** The values of every role for a report. */
+  solve(report: Report, options?: SolveOptions): Solved;
+  /** `solve`, then `defineTheme(name, values, base)`. */
+  apply(report: Report, options?: SolveOptions): Solved;
+}
+/**
+ * The relative luminance of a colour (WCAG 2), as check.contrast reads it.
+ *
+ * @param {string} hex a colour
+ * @returns {number} its luminance, 0 to 1
+ */
+declare const luminance: (hex: string) => number;
+/**
+ * The WCAG 2 contrast ratio of two colours.
+ *
+ * @param {string} a a colour
+ * @param {string} b another
+ * @returns {number} the ratio, 1 to 21
+ */
+declare const contrast: (a: string, b: string) => number;
+/**
+ * A system theme: each token of `roles` takes its hue from a colour of the terminal and its lightness from its contrast
+ * rules against the tokens it sits on. Checks the roles (an `on` without a role, a cycle) and orders them.
+ *
+ * @param {object} tokens the tokens of `createTokens` (cssints/tui)
+ * @param {Roles} roles a role per colour token, in the shape of `tokens`
+ * @param {SystemOptions} options the name, the app's own hues, the static theme under it
+ * @returns {SystemTheme} the theme, for `followSystemTheme` of an adapter, or `solve` and `apply`
+ */
+declare const createSystemTheme: <T extends object>(tokens: T, roles: Roles<T>, options?: SystemOptions) => SystemTheme;
+/** OSC 10 and 11 (the default colours) and OSC 4 for the 16 ANSI colours. */
+declare const COLOURS: string;
+/** The colours and the colour-scheme report (`CSI ? 996 n`). */
+declare const QUERY: string;
+/** Mode 2031 on: the terminal sends `CSI ? 997 ; 1|2 n` when its palette changes. */
+declare const NOTIFY = "[?2031h";
+/** Mode 2031 off. */
+declare const UNNOTIFY = "[?2031l";
+/** What one chunk of input held of the terminal's replies. */
+interface Replies {
+  fg?: string;
+  bg?: string;
+  /** The ANSI colours it reported, by index. */
+  ansi: Map<number, string>;
+  /** The colour scheme of a `CSI ? 997 ; 1|2 n` (a reply to the query, or a notification of a change). */
+  scheme?: Appearance;
+}
+/**
+ * Takes the terminal's replies (OSC 10, 11 and 4, `CSI ? 997 n`) out of a chunk of input, as text of one char per byte.
+ *
+ * @param {string} text the chunk, after what `tail` of the last one kept
+ * @returns {object} the replies, the rest of the input (keys, mouse), and the tail of a reply cut off at the end
+ */
+declare const scan: (text: string) => {
+  replies: Replies;
+  rest: string;
+  tail: string;
+};
+//#endregion
+export { UNNOTIFY as _, NOTIFY as a, luminance as b, Report as c, SLOTS as d, Slot as f, SystemTheme as g, SystemOptions as h, Hue as i, Role as l, Solved as m, COLOURS as n, QUERY as o, SolveOptions as p, ColourToken as r, Replies as s, Appearance as t, Roles as u, contrast as v, scan as x, createSystemTheme as y };

package/dist/system.d.mts

@@ -0,0 +1,2 @@
+import { _ as UNNOTIFY, a as NOTIFY, b as luminance, c as Report, d as SLOTS, f as Slot, g as SystemTheme, h as SystemOptions, i as Hue, l as Role, m as Solved, n as COLOURS, o as QUERY, p as SolveOptions, r as ColourToken, s as Replies, t as Appearance, u as Roles, v as contrast, x as scan, y as createSystemTheme } from "./system-CFyJGOUM.mjs";
+export { Appearance, COLOURS, ColourToken, Hue, NOTIFY, QUERY, Replies, Report, Role, Roles, SLOTS, Slot, SolveOptions, Solved, SystemOptions, SystemTheme, UNNOTIFY, contrast, createSystemTheme, luminance, scan };