@adea-ai/ui 0.123.1 → 0.125.0

package/dist/NOTICE

@@ -300,6 +300,42 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
+## Theme resolution fallback translated from Zeron
+
+`resolveVariant` in `packages/ui/src/lib/themes.ts` translates the fallback order
+of Zeron's `ThemeRegistry::resolve` (https://github.com/zeronsh/zeron), as Adea's
+accepted port of it in `packages/ui/src/components/appearance.ts` expresses it:
+an id the registry does not hold resolves to the default variant of the same
+appearance, then to any variant of that appearance, and never to a variant of the
+other one. The provider's use of it, which leaves the stored id untouched, is the
+Adea behaviour that port retains.
+
+    Copyright (c) 2026 Wing
+    Licensed under the MIT License.
+
+Zeron's MIT notice, reproduced in full under "Appearance editor translated from
+Zeron" above, applies to the translated portion. The ThemeProvider's preview,
+persistence and document-application seams are written against Adea's provider
+contract and introduce no further upstream source.
+
+## Accent roles and colour helpers translated from Zeron
+
+`packages/ui/src/lib/accent-roles.ts` translates Zeron's `Color` helpers and
+`AccentRoles` derivation (https://github.com/zeronsh/zeron), as Adea's accepted
+port of them in `packages/ui/src/components/appearance.ts` expresses it: the hex
+parser and serialiser, the alpha-compositing contrast measure, the contrast
+repair that raises a colour to a floor, the 3:1 interaction
+gate applied to a custom accent, and the per-element paint of an accent's roles.
+The colour engine, the preset values and the role derivation they feed remain
+`@adea-ai/themes`'; the `#rrggbb` selection grammar and the use of the gate in the
+provider are Adea behaviour that port retains.
+
+    Copyright (c) 2026 Wing
+    Licensed under the MIT License.
+
+Zeron's MIT notice, reproduced in full under "Appearance editor translated from
+Zeron" above, applies to the translated portion.
+
 ## Strict binary layout extracted from the accepted Adea donor port
 
 `packages/ui/src/components/layout/split-layout/model.ts` is extracted from

package/dist/components/theme/appearance-panel.js

@@ -7,7 +7,7 @@ import { DEFAULT_APPEARANCE_EDITOR_FONT_SETTINGS } from "../../lib/appearance-fo
 import { AccentSwatchGroups } from "../composites/appearance-editor/accent-swatch-groups.js";
 import { AppearanceFontSettingsGroup } from "../composites/appearance-editor/font-settings-group.js";
 import { ThemePicker } from "./theme-picker.js";
-import { useTheme } from "./theme-provider.js";
+import { useTheme } from "./theme-context.js";
 import { createComponent, insert, mergeProps, spread, template } from "solid-js/web";
 import { Show, splitProps } from "solid-js";
 import { RadioGroup } from "@kobalte/core/radio-group";

package/dist/components/theme/index.d.ts

@@ -1,6 +1,6 @@
 export { AppearancePanel, type AppearancePanelProps } from './appearance-panel';
 export { ThemePicker, ThemePreview, ThemeSwatch, type ThemePickerProps, type ThemePreviewProps, type ThemeSwatchProps, } from './theme-picker';
-export { ThemeProvider, defaultThemeSelection, inlineScriptLiteral, resolvedDensity, themeScript, useTheme, type ThemeContextValue, type ThemeDensity, type ThemeProviderProps, type ThemeSelection, } from './theme-provider';
+export { ThemeProvider, defaultThemeSelection, inlineScriptLiteral, localStoragePersistence, resolvedDensity, themeScript, useOptionalTheme, useTheme, type ThemeContextValue, type ThemeDensity, type ThemePersistence, type ThemeProviderProps, type ThemeSelection, } from './theme-provider';
 export { ThemeToggle, type ThemeToggleProps } from './theme-toggle';
 export { ThemeModeToggle, type ThemeModeToggleProps } from './theme-mode-toggle';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/theme/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/theme/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EACL,WAAW,EACX,YAAY,EACZ,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,WAAW,EACX,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/theme/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EACL,WAAW,EACX,YAAY,EACZ,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/components/theme/index.js

@@ -1,6 +1,9 @@
 import { ThemePicker, ThemePreview, ThemeSwatch } from "./theme-picker.js";
-import { ThemeProvider, defaultThemeSelection, inlineScriptLiteral, resolvedDensity, themeScript, useTheme } from "./theme-provider.js";
+import { useOptionalTheme, useTheme } from "./theme-context.js";
+import { defaultThemeSelection, resolvedDensity } from "./theme-state.js";
+import { localStoragePersistence } from "./theme-persistence.js";
+import { ThemeProvider, inlineScriptLiteral, themeScript } from "./theme-provider.js";
 import { AppearancePanel } from "./appearance-panel.js";
 import { ThemeToggle } from "./theme-toggle.js";
 import { ThemeModeToggle } from "./theme-mode-toggle.js";
-export { AppearancePanel, ThemeModeToggle, ThemePicker, ThemePreview, ThemeProvider, ThemeSwatch, ThemeToggle, defaultThemeSelection, inlineScriptLiteral, resolvedDensity, themeScript, useTheme };
+export { AppearancePanel, ThemeModeToggle, ThemePicker, ThemePreview, ThemeProvider, ThemeSwatch, ThemeToggle, defaultThemeSelection, inlineScriptLiteral, localStoragePersistence, resolvedDensity, themeScript, useOptionalTheme, useTheme };

package/dist/components/theme/theme-context.d.ts

@@ -0,0 +1,13 @@
+import { type Context } from 'solid-js';
+import type { ThemeContextValue } from './theme-state';
+export declare function themeContext(): Context<ThemeContextValue | undefined>;
+export declare function useTheme(): ThemeContextValue;
+/**
+ * The theme context, or `undefined` outside a `ThemeProvider`.
+ *
+ * For a component that can run both ways — a shared control rendered in a harness,
+ * a story, or a host that has not mounted a provider — and would rather degrade
+ * than throw.
+ */
+export declare function useOptionalTheme(): ThemeContextValue | undefined;
+//# sourceMappingURL=theme-context.d.ts.map

package/dist/components/theme/theme-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-context.d.ts","sourceRoot":"","sources":["../../../src/components/theme/theme-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,OAAO,EAAE,MAAM,UAAU,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAqBtD,wBAAgB,YAAY,IAAI,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAGrE;AAED,wBAAgB,QAAQ,IAAI,iBAAiB,CAI5C;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,iBAAiB,GAAG,SAAS,CAEhE"}

package/dist/components/theme/theme-context.js

@@ -0,0 +1,41 @@
+import { createContext, useContext } from "solid-js";
+//#region src/components/theme/theme-context.ts
+/**
+* Where the context object lives: on the global, under a registered symbol.
+*
+* A context is an object identity, and a bundle can legitimately load this module
+* twice — a dev graph where a relative import and a package subpath are distinct
+* module records, or two copies of the package at different versions. Each copy
+* would then call `createContext` and own its own object; a provider from one and a
+* `useOptionalTheme()` from the other would never meet, and the second would return
+* `undefined` as though no provider were mounted. `Symbol.for` is shared across
+* every copy in a realm, so they all find the one context the first created.
+*
+* Both copies must agree on its shape. The context value only ever grows, which is
+* why a newer provider under an older reader is safe and the reverse is a missing
+* member, not a mismatch.
+*/
+var CONTEXT_KEY = Symbol.for("adea.ui.theme");
+function themeContext() {
+	const host = globalThis;
+	return host[CONTEXT_KEY] ??= createContext();
+}
+function useTheme() {
+	const value = useContext(themeContext());
+	if (!value) throw new Error("useTheme must be called inside a <ThemeProvider>.");
+	return value;
+}
+/**
+* The theme context, or `undefined` outside a `ThemeProvider`.
+*
+* For a component that can run both ways — a shared control rendered in a harness,
+* a story, or a host that has not mounted a provider — and would rather degrade
+* than throw.
+*/
+function useOptionalTheme() {
+	return useContext(themeContext());
+}
+//#endregion
+export { themeContext, useOptionalTheme, useTheme };
+
+//# sourceMappingURL=theme-context.js.map

package/dist/components/theme/theme-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-context.js","names":[],"sources":["../../../src/components/theme/theme-context.ts"],"sourcesContent":["import { createContext, useContext, type Context } from 'solid-js'\nimport type { ThemeContextValue } from './theme-state'\n\n/**\n * Where the context object lives: on the global, under a registered symbol.\n *\n * A context is an object identity, and a bundle can legitimately load this module\n * twice — a dev graph where a relative import and a package subpath are distinct\n * module records, or two copies of the package at different versions. Each copy\n * would then call `createContext` and own its own object; a provider from one and a\n * `useOptionalTheme()` from the other would never meet, and the second would return\n * `undefined` as though no provider were mounted. `Symbol.for` is shared across\n * every copy in a realm, so they all find the one context the first created.\n *\n * Both copies must agree on its shape. The context value only ever grows, which is\n * why a newer provider under an older reader is safe and the reverse is a missing\n * member, not a mismatch.\n */\nconst CONTEXT_KEY = Symbol.for('adea.ui.theme')\n\ntype ContextHost = { [CONTEXT_KEY]?: Context<ThemeContextValue | undefined> }\n\nexport function themeContext(): Context<ThemeContextValue | undefined> {\n  const host = globalThis as ContextHost\n  return (host[CONTEXT_KEY] ??= createContext<ThemeContextValue>())\n}\n\nexport function useTheme(): ThemeContextValue {\n  const value = useContext(themeContext())\n  if (!value) throw new Error('useTheme must be called inside a <ThemeProvider>.')\n  return value\n}\n\n/**\n * The theme context, or `undefined` outside a `ThemeProvider`.\n *\n * For a component that can run both ways — a shared control rendered in a harness,\n * a story, or a host that has not mounted a provider — and would rather degrade\n * than throw.\n */\nexport function useOptionalTheme(): ThemeContextValue | undefined {\n  return useContext(themeContext())\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,IAAM,cAAc,OAAO,IAAI,eAAe;AAI9C,SAAgB,eAAuD;CACrE,MAAM,OAAO;CACb,OAAQ,KAAK,iBAAiB,cAAiC;AACjE;AAEA,SAAgB,WAA8B;CAC5C,MAAM,QAAQ,WAAW,aAAa,CAAC;CACvC,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,mDAAmD;CAC/E,OAAO;AACT;;;;;;;;AASA,SAAgB,mBAAkD;CAChE,OAAO,WAAW,aAAa,CAAC;AAClC"}

package/dist/components/theme/theme-document.d.ts

@@ -0,0 +1,82 @@
+import { type ThemeAppearance, type ThemeVariant } from '#lib/themes';
+import { type ThemeSelection } from './theme-state';
+/**
+ * The document half of the theme provider: the single writer of `<html>`.
+ *
+ * Written against the few members of an element it uses, so the rules can be tested
+ * on a stand-in and the provider's effect stays a one-line call.
+ */
+export type ThemeRoot = Pick<HTMLElement, 'classList' | 'dataset' | 'style' | 'removeAttribute' | 'setAttribute'>;
+export type ThemeDocumentState = {
+    /** What the document shows: the committed selection, or a preview laid over it. */
+    selection: ThemeSelection;
+    appearance: ThemeAppearance;
+    variant: ThemeVariant;
+};
+export type ThemeDocumentOptions = {
+    /**
+     * Rewrites the custom properties just before they are written: the variant's
+     * roles with the accent laid over them. It sees every property of the pass and
+     * must return the full map; a name it drops is not written.
+     */
+    transformTokens?: (tokens: Record<string, string>) => Record<string, string>;
+    /**
+     * The contrast an accent is held to against the variant's background. Absent, a
+     * preset is painted verbatim (the catalogue measured it for its own themes) and
+     * only a custom `#rrggbb` is held to the default floor of 3:1.
+     */
+    accentContrastFloor?: number;
+};
+/**
+ * The custom properties a state paints: the variant's roles, with the accent
+ * selection laid over them, then `transformTokens`.
+ *
+ * The accent is applied *here* rather than left to the `[data-accent]` blocks in
+ * `theme.css`, because the properties are written inline and an inline declaration
+ * outranks every stylesheet selector however specific it is. The blocks still exist
+ * and are still correct — they are what styles the window before this runs — but
+ * they cannot win from here, so leaving the accent to them meant the attribute was
+ * set, the rules were present, and nothing changed on screen.
+ */
+export declare function themeDocumentTokens(state: ThemeDocumentState, options?: ThemeDocumentOptions): {
+    tokens: Record<string, string>;
+    accented: boolean;
+};
+/**
+ * Write a state onto a root and report which custom properties it owns.
+ *
+ * Pass the previous call's return as `previous` and any palette property that pass
+ * wrote and this one does not is removed. For the catalogue the two sets are the
+ * same, so nothing is ever removed; it matters for a host variant that carries
+ * `tokens` the catalogue does not, which would otherwise stay inline, beating the
+ * stylesheet, after the user switched away from it.
+ */
+export declare function applyThemeToRoot(root: ThemeRoot, state: ThemeDocumentState, options?: ThemeDocumentOptions, previous?: ReadonlySet<string>): ReadonlySet<string>;
+/** What {@link applyWithoutTransitions} needs of a document. */
+export type TransitionDocument = {
+    head: {
+        appendChild(node: unknown): unknown;
+    };
+    createElement(tag: 'style'): {
+        textContent: string | null;
+        offsetHeight?: number;
+        remove(): void;
+    };
+};
+/**
+ * Run `apply` with every CSS transition switched off for the frame that carries
+ * it, so a theme switch cannot animate page-wide.
+ *
+ * Without this, flipping the custom properties on `<html>` starts a transition on
+ * every element that declares one, and each fades from the old palette to the new
+ * over its own duration: a theme change that looks like a rendering fault. The
+ * rule is removed two frames later, after the browser has committed the new styles
+ * with transitions off, and `restore` runs it early (the provider calls it when it
+ * is disposed mid-switch).
+ *
+ * `schedule` is the frame source; it defaults to `requestAnimationFrame` and falls
+ * back to running at once where there is none, which leaves transitions on rather
+ * than off.
+ */
+export declare function applyWithoutTransitions(doc: TransitionDocument, apply: () => void, schedule?: (callback: () => void) => void): () => void;
+//# sourceMappingURL=theme-document.d.ts.map

package/dist/components/theme/theme-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-document.d.ts","sourceRoot":"","sources":["../../../src/components/theme/theme-document.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAEpE;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,CAC1B,WAAW,EACX,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,iBAAiB,GAAG,cAAc,CACvE,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,mFAAmF;IACnF,SAAS,EAAE,cAAc,CAAA;IACzB,UAAU,EAAE,eAAe,CAAA;IAC3B,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5E;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,kBAAkB,EACzB,OAAO,GAAE,oBAAyB,GACjC;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAYvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,kBAAkB,EACzB,OAAO,GAAE,oBAAyB,EAClC,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC7B,WAAW,CAAC,MAAM,CAAC,CAsCrB;AAED,gEAAgE;AAChE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE;QAAE,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;KAAE,CAAA;IAC7C,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG;QAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;QAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;QACrB,MAAM,IAAI,IAAI,CAAA;KACf,CAAA;CACF,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,MAAM,IAAI,EACjB,QAAQ,GAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAsB,GACzD,MAAM,IAAI,CAqBZ"}

package/dist/components/theme/theme-document.js

@@ -0,0 +1,98 @@
+import { isCustomAccent } from "../../lib/accent-roles.js";
+import { accentVariables, themeCssVariables } from "../../lib/themes.js";
+import { applyAppearanceFontSettings, normalizeAppearanceEditorFontSettings } from "../../lib/appearance-font-settings.js";
+import { resolvedDensity } from "./theme-state.js";
+//#region src/components/theme/theme-document.ts
+/**
+* The custom properties a state paints: the variant's roles, with the accent
+* selection laid over them, then `transformTokens`.
+*
+* The accent is applied *here* rather than left to the `[data-accent]` blocks in
+* `theme.css`, because the properties are written inline and an inline declaration
+* outranks every stylesheet selector however specific it is. The blocks still exist
+* and are still correct — they are what styles the window before this runs — but
+* they cannot win from here, so leaving the accent to them meant the attribute was
+* set, the rules were present, and nothing changed on screen.
+*/
+function themeDocumentTokens(state, options = {}) {
+	const properties = { ...themeCssVariables(state.variant) };
+	const accent = accentVariables(state.selection.accent, state.appearance, state.selection, {
+		background: state.variant.colors.background,
+		floor: options.accentContrastFloor,
+		variantId: state.variant.id
+	});
+	if (accent) Object.assign(properties, accent);
+	return {
+		tokens: options.transformTokens ? options.transformTokens(properties) : properties,
+		accented: accent !== void 0
+	};
+}
+/**
+* Write a state onto a root and report which custom properties it owns.
+*
+* Pass the previous call's return as `previous` and any palette property that pass
+* wrote and this one does not is removed. For the catalogue the two sets are the
+* same, so nothing is ever removed; it matters for a host variant that carries
+* `tokens` the catalogue does not, which would otherwise stay inline, beating the
+* stylesheet, after the user switched away from it.
+*/
+function applyThemeToRoot(root, state, options = {}, previous) {
+	const { tokens, accented } = themeDocumentTokens(state, options);
+	for (const [name, value] of Object.entries(tokens)) root.style.setProperty(name, value);
+	if (previous) {
+		for (const name of previous) if (!(name in tokens)) root.style.removeProperty(name);
+	}
+	root.classList.toggle("dark", state.appearance === "dark");
+	root.dataset["theme"] = state.variant.id;
+	root.dataset["appearance"] = state.appearance;
+	root.style.colorScheme = state.appearance;
+	if (!accented) root.removeAttribute("data-accent");
+	else root.dataset["accent"] = isCustomAccent(state.selection.accent) ? "custom" : state.selection.accent;
+	applyAppearanceFontSettings(root, normalizeAppearanceEditorFontSettings(state.selection.fonts, state.selection.font).settings);
+	if (resolvedDensity(state.selection) === "comfortable") root.removeAttribute("data-density");
+	else root.dataset["density"] = resolvedDensity(state.selection);
+	return new Set(Object.keys(tokens));
+}
+/**
+* Run `apply` with every CSS transition switched off for the frame that carries
+* it, so a theme switch cannot animate page-wide.
+*
+* Without this, flipping the custom properties on `<html>` starts a transition on
+* every element that declares one, and each fades from the old palette to the new
+* over its own duration: a theme change that looks like a rendering fault. The
+* rule is removed two frames later, after the browser has committed the new styles
+* with transitions off, and `restore` runs it early (the provider calls it when it
+* is disposed mid-switch).
+*
+* `schedule` is the frame source; it defaults to `requestAnimationFrame` and falls
+* back to running at once where there is none, which leaves transitions on rather
+* than off.
+*/
+function applyWithoutTransitions(doc, apply, schedule = defaultSchedule) {
+	const style = doc.createElement("style");
+	style.textContent = "*{transition:none !important}";
+	doc.head.appendChild(style);
+	style.offsetHeight;
+	let removed = false;
+	const restore = () => {
+		if (removed) return;
+		removed = true;
+		style.remove();
+	};
+	try {
+		apply();
+	} catch (error) {
+		restore();
+		throw error;
+	}
+	schedule(() => schedule(restore));
+	return restore;
+}
+function defaultSchedule(callback) {
+	if (typeof requestAnimationFrame === "function") requestAnimationFrame(callback);
+	else callback();
+}
+//#endregion
+export { applyThemeToRoot, applyWithoutTransitions, themeDocumentTokens };
+
+//# sourceMappingURL=theme-document.js.map

package/dist/components/theme/theme-document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-document.js","names":[],"sources":["../../../src/components/theme/theme-document.ts"],"sourcesContent":["import {\n  applyAppearanceFontSettings,\n  normalizeAppearanceEditorFontSettings,\n} from '#lib/appearance-font-settings'\nimport {\n  accentVariables,\n  themeCssVariables,\n  type ThemeAppearance,\n  type ThemeVariant,\n} from '#lib/themes'\nimport { isCustomAccent } from '#lib/accent-roles'\nimport { resolvedDensity, type ThemeSelection } from './theme-state'\n\n/**\n * The document half of the theme provider: the single writer of `<html>`.\n *\n * Written against the few members of an element it uses, so the rules can be tested\n * on a stand-in and the provider's effect stays a one-line call.\n */\nexport type ThemeRoot = Pick<\n  HTMLElement,\n  'classList' | 'dataset' | 'style' | 'removeAttribute' | 'setAttribute'\n>\n\nexport type ThemeDocumentState = {\n  /** What the document shows: the committed selection, or a preview laid over it. */\n  selection: ThemeSelection\n  appearance: ThemeAppearance\n  variant: ThemeVariant\n}\n\nexport type ThemeDocumentOptions = {\n  /**\n   * Rewrites the custom properties just before they are written: the variant's\n   * roles with the accent laid over them. It sees every property of the pass and\n   * must return the full map; a name it drops is not written.\n   */\n  transformTokens?: (tokens: Record<string, string>) => Record<string, string>\n  /**\n   * The contrast an accent is held to against the variant's background. Absent, a\n   * preset is painted verbatim (the catalogue measured it for its own themes) and\n   * only a custom `#rrggbb` is held to the default floor of 3:1.\n   */\n  accentContrastFloor?: number\n}\n\n/**\n * The custom properties a state paints: the variant's roles, with the accent\n * selection laid over them, then `transformTokens`.\n *\n * The accent is applied *here* rather than left to the `[data-accent]` blocks in\n * `theme.css`, because the properties are written inline and an inline declaration\n * outranks every stylesheet selector however specific it is. The blocks still exist\n * and are still correct — they are what styles the window before this runs — but\n * they cannot win from here, so leaving the accent to them meant the attribute was\n * set, the rules were present, and nothing changed on screen.\n */\nexport function themeDocumentTokens(\n  state: ThemeDocumentState,\n  options: ThemeDocumentOptions = {}\n): { tokens: Record<string, string>; accented: boolean } {\n  const properties = { ...themeCssVariables(state.variant) }\n  const accent = accentVariables(state.selection.accent, state.appearance, state.selection, {\n    background: state.variant.colors.background,\n    floor: options.accentContrastFloor,\n    variantId: state.variant.id,\n  })\n  if (accent) Object.assign(properties, accent)\n  return {\n    tokens: options.transformTokens ? options.transformTokens(properties) : properties,\n    accented: accent !== undefined,\n  }\n}\n\n/**\n * Write a state onto a root and report which custom properties it owns.\n *\n * Pass the previous call's return as `previous` and any palette property that pass\n * wrote and this one does not is removed. For the catalogue the two sets are the\n * same, so nothing is ever removed; it matters for a host variant that carries\n * `tokens` the catalogue does not, which would otherwise stay inline, beating the\n * stylesheet, after the user switched away from it.\n */\nexport function applyThemeToRoot(\n  root: ThemeRoot,\n  state: ThemeDocumentState,\n  options: ThemeDocumentOptions = {},\n  previous?: ReadonlySet<string>\n): ReadonlySet<string> {\n  const { tokens, accented } = themeDocumentTokens(state, options)\n\n  for (const [name, value] of Object.entries(tokens)) {\n    root.style.setProperty(name, value)\n  }\n  if (previous) {\n    for (const name of previous) {\n      if (!(name in tokens)) root.style.removeProperty(name)\n    }\n  }\n\n  root.classList.toggle('dark', state.appearance === 'dark')\n  root.dataset['theme'] = state.variant.id\n  root.dataset['appearance'] = state.appearance\n  root.style.colorScheme = state.appearance\n\n  // A custom colour has no stylesheet block to select, and its value is the\n  // attribute's worst possible content, so it is reported as `custom`.\n  if (!accented) root.removeAttribute('data-accent')\n  else\n    root.dataset['accent'] = isCustomAccent(state.selection.accent)\n      ? 'custom'\n      : state.selection.accent\n\n  applyAppearanceFontSettings(\n    root,\n    normalizeAppearanceEditorFontSettings(state.selection.fonts, state.selection.font).settings\n  )\n\n  // Density is a pure token shift, so unlike the colour axes there is nothing to\n  // compute: the attribute selects a block in `theme.css`. It is applied here for\n  // the same reason as the others — this is the one place that knows what the\n  // current selection is, and it is the only writer of these attributes.\n  if (resolvedDensity(state.selection) === 'comfortable') root.removeAttribute('data-density')\n  else root.dataset['density'] = resolvedDensity(state.selection)\n\n  return new Set(Object.keys(tokens))\n}\n\n/** What {@link applyWithoutTransitions} needs of a document. */\nexport type TransitionDocument = {\n  head: { appendChild(node: unknown): unknown }\n  createElement(tag: 'style'): {\n    textContent: string | null\n    offsetHeight?: number\n    remove(): void\n  }\n}\n\n/**\n * Run `apply` with every CSS transition switched off for the frame that carries\n * it, so a theme switch cannot animate page-wide.\n *\n * Without this, flipping the custom properties on `<html>` starts a transition on\n * every element that declares one, and each fades from the old palette to the new\n * over its own duration: a theme change that looks like a rendering fault. The\n * rule is removed two frames later, after the browser has committed the new styles\n * with transitions off, and `restore` runs it early (the provider calls it when it\n * is disposed mid-switch).\n *\n * `schedule` is the frame source; it defaults to `requestAnimationFrame` and falls\n * back to running at once where there is none, which leaves transitions on rather\n * than off.\n */\nexport function applyWithoutTransitions(\n  doc: TransitionDocument,\n  apply: () => void,\n  schedule: (callback: () => void) => void = defaultSchedule\n): () => void {\n  const style = doc.createElement('style')\n  style.textContent = '*{transition:none !important}'\n  doc.head.appendChild(style)\n  // Reading a layout property forces the browser to commit the rule before the\n  // properties change; without it the two can be batched into one style recalc.\n  void style.offsetHeight\n  let removed = false\n  const restore = () => {\n    if (removed) return\n    removed = true\n    style.remove()\n  }\n  try {\n    apply()\n  } catch (error) {\n    restore()\n    throw error\n  }\n  schedule(() => schedule(restore))\n  return restore\n}\n\nfunction defaultSchedule(callback: () => void): void {\n  if (typeof requestAnimationFrame === 'function') requestAnimationFrame(callback)\n  else callback()\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAyDA,SAAgB,oBACd,OACA,UAAgC,CAAC,GACsB;CACvD,MAAM,aAAa,EAAE,GAAG,kBAAkB,MAAM,OAAO,EAAE;CACzD,MAAM,SAAS,gBAAgB,MAAM,UAAU,QAAQ,MAAM,YAAY,MAAM,WAAW;EACxF,YAAY,MAAM,QAAQ,OAAO;EACjC,OAAO,QAAQ;EACf,WAAW,MAAM,QAAQ;CAC3B,CAAC;CACD,IAAI,QAAQ,OAAO,OAAO,YAAY,MAAM;CAC5C,OAAO;EACL,QAAQ,QAAQ,kBAAkB,QAAQ,gBAAgB,UAAU,IAAI;EACxE,UAAU,WAAW,KAAA;CACvB;AACF;;;;;;;;;;AAWA,SAAgB,iBACd,MACA,OACA,UAAgC,CAAC,GACjC,UACqB;CACrB,MAAM,EAAE,QAAQ,aAAa,oBAAoB,OAAO,OAAO;CAE/D,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,GAC/C,KAAK,MAAM,YAAY,MAAM,KAAK;CAEpC,IAAI,UACG;OAAA,MAAM,QAAQ,UACjB,IAAI,EAAE,QAAQ,SAAS,KAAK,MAAM,eAAe,IAAI;CAAA;CAIzD,KAAK,UAAU,OAAO,QAAQ,MAAM,eAAe,MAAM;CACzD,KAAK,QAAQ,WAAW,MAAM,QAAQ;CACtC,KAAK,QAAQ,gBAAgB,MAAM;CACnC,KAAK,MAAM,cAAc,MAAM;CAI/B,IAAI,CAAC,UAAU,KAAK,gBAAgB,aAAa;MAE/C,KAAK,QAAQ,YAAY,eAAe,MAAM,UAAU,MAAM,IAC1D,WACA,MAAM,UAAU;CAEtB,4BACE,MACA,sCAAsC,MAAM,UAAU,OAAO,MAAM,UAAU,IAAI,CAAC,CAAC,QACrF;CAMA,IAAI,gBAAgB,MAAM,SAAS,MAAM,eAAe,KAAK,gBAAgB,cAAc;MACtF,KAAK,QAAQ,aAAa,gBAAgB,MAAM,SAAS;CAE9D,OAAO,IAAI,IAAI,OAAO,KAAK,MAAM,CAAC;AACpC;;;;;;;;;;;;;;;;AA2BA,SAAgB,wBACd,KACA,OACA,WAA2C,iBAC/B;CACZ,MAAM,QAAQ,IAAI,cAAc,OAAO;CACvC,MAAM,cAAc;CACpB,IAAI,KAAK,YAAY,KAAK;CAG1B,MAAW;CACX,IAAI,UAAU;CACd,MAAM,gBAAgB;EACpB,IAAI,SAAS;EACb,UAAU;EACV,MAAM,OAAO;CACf;CACA,IAAI;EACF,MAAM;CACR,SAAS,OAAO;EACd,QAAQ;EACR,MAAM;CACR;CACA,eAAe,SAAS,OAAO,CAAC;CAChC,OAAO;AACT;AAEA,SAAS,gBAAgB,UAA4B;CACnD,IAAI,OAAO,0BAA0B,YAAY,sBAAsB,QAAQ;MAC1E,SAAS;AAChB"}

package/dist/components/theme/theme-persistence.d.ts

@@ -0,0 +1,50 @@
+import { type ThemeSelection } from './theme-state';
+/**
+ * Where a selection is kept between sessions.
+ *
+ * The provider never touches storage itself; it asks a `ThemePersistence`. The
+ * default is {@link localStoragePersistence}, which is what the provider always did.
+ * A host that stores the preference in a different shape, under a versioned
+ * envelope, or somewhere that is not `localStorage` supplies its own and the
+ * resolution and application rules stay the shared ones.
+ *
+ * The contract is deliberately narrow, so that an implementation cannot make the
+ * provider less safe than it was:
+ *
+ *   - `read` is synchronous and runs once, when the provider is created. It may
+ *     repair or quarantine what it finds, and it must not throw: the provider
+ *     treats a throw as "nothing stored" and starts from the defaults.
+ *   - `write` runs only from `setSelection`. Never on mount, never from `preview`,
+ *     never as a side effect of reading, so the first write to a store is always a
+ *     user's decision. A throw is swallowed, because a full or blocked store must
+ *     not break the switch.
+ */
+export type ThemePersistence = {
+    read(): Partial<ThemeSelection> | undefined;
+    write(next: ThemeSelection): void;
+};
+/**
+ * The default persistence: one JSON document in `localStorage` under `key`.
+ *
+ * `read` is the provider's original `readSelection`, moved here unchanged — every
+ * stored id is validated against the catalogue, so a stale preference falls back to
+ * a default rather than reaching the document. `key` may be a function so a
+ * provider whose `storageKey` prop changes writes to the key it is now given.
+ *
+ * Blocked, full or absent storage is survivable in both directions: a read answers
+ * with the defaults and a write is dropped, so the preference simply lasts the
+ * session.
+ */
+export declare function localStoragePersistence(key: string | (() => string)): ThemePersistence;
+/**
+ * What a persistence knows, or nothing.
+ *
+ * The seam's `read` must not throw, and the provider does not rely on that: a host
+ * persistence is code the design system has not seen, and a theme provider that
+ * fails to mount because a store misbehaved has turned a lost preference into a
+ * blank application.
+ */
+export declare function readPersisted(persistence: ThemePersistence): Partial<ThemeSelection> | undefined;
+/** Hand a selection to the store; a store that throws loses the preference, not the switch. */
+export declare function writePersisted(persistence: ThemePersistence, next: ThemeSelection): void;
+//# sourceMappingURL=theme-persistence.d.ts.map

package/dist/components/theme/theme-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-persistence.d.ts","sourceRoot":"","sources":["../../../src/components/theme/theme-persistence.ts"],"names":[],"mappings":"AAIA,OAAO,EAA0C,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAE3F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3C,KAAK,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAA;CAClC,CAAA;AA8DD;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,GAAG,gBAAgB,CAatF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,CAMhG;AAED,+FAA+F;AAC/F,wBAAgB,cAAc,CAAC,WAAW,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAOxF"}

package/dist/components/theme/theme-persistence.js

@@ -0,0 +1,87 @@
+import { accentPresets } from "../../lib/tokens.js";
+import { normalizeCustomAccent } from "../../lib/accent-roles.js";
+import { isThemeAccentId } from "../../lib/theme-accents.js";
+import { defaultDarkThemeId, defaultLightThemeId, themeById } from "../../lib/themes.js";
+import { normalizeAppearanceEditorFontSettings } from "../../lib/appearance-font-settings.js";
+import { defaultThemeSelection, resolvedDensity } from "./theme-state.js";
+//#region src/components/theme/theme-persistence.ts
+/**
+* The preference store, or nothing.
+*
+* Only ever called inside a `try`: where storage is blocked — a sandboxed iframe, a
+* privacy mode, a denied site-data permission — merely *reading* the `localStorage`
+* global throws ("Access is denied", `SecurityError`), so even the `typeof` guard
+* has to sit inside the `try` rather than in front of it. Without a store the
+* preference lives only in the provider's signal for the session.
+*/
+function preferenceStore() {
+	return typeof localStorage === "undefined" ? void 0 : localStorage;
+}
+/** The stored preference, validated against the catalogue. */
+function readSelection(storageKey) {
+	try {
+		const raw = preferenceStore()?.getItem(storageKey);
+		if (!raw) return defaultThemeSelection;
+		const parsed = JSON.parse(raw);
+		const fonts = normalizeAppearanceEditorFontSettings(parsed.fonts, parsed.font).settings;
+		return {
+			appearance: parsed.appearance === "light" || parsed.appearance === "dark" || parsed.appearance === "system" ? parsed.appearance : defaultThemeSelection.appearance,
+			lightThemeId: themeById(parsed.lightThemeId ?? "")?.appearance === "light" ? parsed.lightThemeId : defaultLightThemeId,
+			darkThemeId: themeById(parsed.darkThemeId ?? "")?.appearance === "dark" ? parsed.darkThemeId : defaultDarkThemeId,
+			accent: typeof parsed.accent === "string" && (accentPresets.some((preset) => preset.id === parsed.accent) || isThemeAccentId(parsed.accent)) ? parsed.accent : normalizeCustomAccent(parsed.accent) ?? defaultThemeSelection.accent,
+			font: fonts.ui.family,
+			fonts,
+			density: resolvedDensity(parsed)
+		};
+	} catch {
+		return defaultThemeSelection;
+	}
+}
+/**
+* The default persistence: one JSON document in `localStorage` under `key`.
+*
+* `read` is the provider's original `readSelection`, moved here unchanged — every
+* stored id is validated against the catalogue, so a stale preference falls back to
+* a default rather than reaching the document. `key` may be a function so a
+* provider whose `storageKey` prop changes writes to the key it is now given.
+*
+* Blocked, full or absent storage is survivable in both directions: a read answers
+* with the defaults and a write is dropped, so the preference simply lasts the
+* session.
+*/
+function localStoragePersistence(key) {
+	const keyOf = () => typeof key === "function" ? key() : key;
+	return {
+		read: () => readSelection(keyOf()),
+		write(next) {
+			try {
+				preferenceStore()?.setItem(keyOf(), JSON.stringify(next));
+			} catch {}
+		}
+	};
+}
+/**
+* What a persistence knows, or nothing.
+*
+* The seam's `read` must not throw, and the provider does not rely on that: a host
+* persistence is code the design system has not seen, and a theme provider that
+* fails to mount because a store misbehaved has turned a lost preference into a
+* blank application.
+*/
+function readPersisted(persistence) {
+	try {
+		return persistence.read();
+	} catch {
+		return;
+	}
+}
+/** Hand a selection to the store; a store that throws loses the preference, not the switch. */
+function writePersisted(persistence, next) {
+	try {
+		persistence.write(next);
+	} catch {}
+}
+//#endregion
+export { localStoragePersistence, readPersisted, writePersisted };
+
+//# sourceMappingURL=theme-persistence.js.map

package/dist/components/theme/theme-persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-persistence.js","names":[],"sources":["../../../src/components/theme/theme-persistence.ts"],"sourcesContent":["import { normalizeCustomAccent } from '#lib/accent-roles'\nimport { accentPresets } from '#lib/tokens'\nimport { normalizeAppearanceEditorFontSettings } from '#lib/appearance-font-settings'\nimport { defaultDarkThemeId, defaultLightThemeId, isThemeAccentId, themeById } from '#lib/themes'\nimport { defaultThemeSelection, resolvedDensity, type ThemeSelection } from './theme-state'\n\n/**\n * Where a selection is kept between sessions.\n *\n * The provider never touches storage itself; it asks a `ThemePersistence`. The\n * default is {@link localStoragePersistence}, which is what the provider always did.\n * A host that stores the preference in a different shape, under a versioned\n * envelope, or somewhere that is not `localStorage` supplies its own and the\n * resolution and application rules stay the shared ones.\n *\n * The contract is deliberately narrow, so that an implementation cannot make the\n * provider less safe than it was:\n *\n *   - `read` is synchronous and runs once, when the provider is created. It may\n *     repair or quarantine what it finds, and it must not throw: the provider\n *     treats a throw as \"nothing stored\" and starts from the defaults.\n *   - `write` runs only from `setSelection`. Never on mount, never from `preview`,\n *     never as a side effect of reading, so the first write to a store is always a\n *     user's decision. A throw is swallowed, because a full or blocked store must\n *     not break the switch.\n */\nexport type ThemePersistence = {\n  read(): Partial<ThemeSelection> | undefined\n  write(next: ThemeSelection): void\n}\n\n/**\n * The preference store, or nothing.\n *\n * Only ever called inside a `try`: where storage is blocked — a sandboxed iframe, a\n * privacy mode, a denied site-data permission — merely *reading* the `localStorage`\n * global throws (\"Access is denied\", `SecurityError`), so even the `typeof` guard\n * has to sit inside the `try` rather than in front of it. Without a store the\n * preference lives only in the provider's signal for the session.\n */\nfunction preferenceStore(): Storage | undefined {\n  return typeof localStorage === 'undefined' ? undefined : localStorage\n}\n\n/** The stored preference, validated against the catalogue. */\nfunction readSelection(storageKey: string): ThemeSelection {\n  try {\n    const raw = preferenceStore()?.getItem(storageKey)\n    if (!raw) return defaultThemeSelection\n    const parsed = JSON.parse(raw) as Partial<ThemeSelection>\n    const fonts = normalizeAppearanceEditorFontSettings(parsed.fonts, parsed.font).settings\n    return {\n      appearance:\n        parsed.appearance === 'light' ||\n        parsed.appearance === 'dark' ||\n        parsed.appearance === 'system'\n          ? parsed.appearance\n          : defaultThemeSelection.appearance,\n      // An unknown id would leave the document with no theme at all, so a stale\n      // preference from an older catalogue falls back rather than applying nothing.\n      lightThemeId:\n        themeById(parsed.lightThemeId ?? '')?.appearance === 'light'\n          ? (parsed.lightThemeId as string)\n          : defaultLightThemeId,\n      darkThemeId:\n        themeById(parsed.darkThemeId ?? '')?.appearance === 'dark'\n          ? (parsed.darkThemeId as string)\n          : defaultDarkThemeId,\n      // A theme accent is kept whenever it names a slot, even one the stored pair\n      // cannot offer: the id is role-shaped so it survives a theme switch, and an\n      // unoffered slot already resolves to the theme's own primary when applied. A\n      // custom `#rrggbb` is kept in its one stored spelling; its readability is\n      // settled when it is painted, not when it is read.\n      accent:\n        typeof parsed.accent === 'string' &&\n        (accentPresets.some((preset) => preset.id === parsed.accent) ||\n          isThemeAccentId(parsed.accent))\n          ? parsed.accent\n          : (normalizeCustomAccent(parsed.accent) ?? defaultThemeSelection.accent),\n      font: fonts.ui.family,\n      fonts,\n      // Every axis has to be read back here, or it is lost twice: the provider's\n      // document effect removes the `data-density` that `themeScript` set for the first paint, and\n      // the next `setSelection` rewrites the store without it.\n      density: resolvedDensity(parsed as ThemeSelection),\n    }\n  } catch {\n    return defaultThemeSelection\n  }\n}\n\n/**\n * The default persistence: one JSON document in `localStorage` under `key`.\n *\n * `read` is the provider's original `readSelection`, moved here unchanged — every\n * stored id is validated against the catalogue, so a stale preference falls back to\n * a default rather than reaching the document. `key` may be a function so a\n * provider whose `storageKey` prop changes writes to the key it is now given.\n *\n * Blocked, full or absent storage is survivable in both directions: a read answers\n * with the defaults and a write is dropped, so the preference simply lasts the\n * session.\n */\nexport function localStoragePersistence(key: string | (() => string)): ThemePersistence {\n  const keyOf = () => (typeof key === 'function' ? key() : key)\n  return {\n    read: () => readSelection(keyOf()),\n    write(next) {\n      try {\n        preferenceStore()?.setItem(keyOf(), JSON.stringify(next))\n      } catch {\n        // A full, blocked or unavailable store must not break the switch: the\n        // preference simply does not survive the reload.\n      }\n    },\n  }\n}\n\n/**\n * What a persistence knows, or nothing.\n *\n * The seam's `read` must not throw, and the provider does not rely on that: a host\n * persistence is code the design system has not seen, and a theme provider that\n * fails to mount because a store misbehaved has turned a lost preference into a\n * blank application.\n */\nexport function readPersisted(persistence: ThemePersistence): Partial<ThemeSelection> | undefined {\n  try {\n    return persistence.read()\n  } catch {\n    return undefined\n  }\n}\n\n/** Hand a selection to the store; a store that throws loses the preference, not the switch. */\nexport function writePersisted(persistence: ThemePersistence, next: ThemeSelection): void {\n  try {\n    persistence.write(next)\n  } catch {\n    // Same contract as a full or blocked `localStorage`: the choice holds for the\n    // session and does not survive the reload.\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAwCA,SAAS,kBAAuC;CAC9C,OAAO,OAAO,iBAAiB,cAAc,KAAA,IAAY;AAC3D;;AAGA,SAAS,cAAc,YAAoC;CACzD,IAAI;EACF,MAAM,MAAM,gBAAgB,CAAC,EAAE,QAAQ,UAAU;EACjD,IAAI,CAAC,KAAK,OAAO;EACjB,MAAM,SAAS,KAAK,MAAM,GAAG;EAC7B,MAAM,QAAQ,sCAAsC,OAAO,OAAO,OAAO,IAAI,CAAC,CAAC;EAC/E,OAAO;GACL,YACE,OAAO,eAAe,WACtB,OAAO,eAAe,UACtB,OAAO,eAAe,WAClB,OAAO,aACP,sBAAsB;GAG5B,cACE,UAAU,OAAO,gBAAgB,EAAE,CAAC,EAAE,eAAe,UAChD,OAAO,eACR;GACN,aACE,UAAU,OAAO,eAAe,EAAE,CAAC,EAAE,eAAe,SAC/C,OAAO,cACR;GAMN,QACE,OAAO,OAAO,WAAW,aACxB,cAAc,MAAM,WAAW,OAAO,OAAO,OAAO,MAAM,KACzD,gBAAgB,OAAO,MAAM,KAC3B,OAAO,SACN,sBAAsB,OAAO,MAAM,KAAK,sBAAsB;GACrE,MAAM,MAAM,GAAG;GACf;GAIA,SAAS,gBAAgB,MAAwB;EACnD;CACF,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;AAcA,SAAgB,wBAAwB,KAAgD;CACtF,MAAM,cAAe,OAAO,QAAQ,aAAa,IAAI,IAAI;CACzD,OAAO;EACL,YAAY,cAAc,MAAM,CAAC;EACjC,MAAM,MAAM;GACV,IAAI;IACF,gBAAgB,CAAC,EAAE,QAAQ,MAAM,GAAG,KAAK,UAAU,IAAI,CAAC;GAC1D,QAAQ,CAGR;EACF;CACF;AACF;;;;;;;;;AAUA,SAAgB,cAAc,aAAoE;CAChG,IAAI;EACF,OAAO,YAAY,KAAK;CAC1B,QAAQ;EACN;CACF;AACF;;AAGA,SAAgB,eAAe,aAA+B,MAA4B;CACxF,IAAI;EACF,YAAY,MAAM,IAAI;CACxB,QAAQ,CAGR;AACF"}