dsh-code 1.0.7 → 1.2.0

package/lib/{theme-DCT8Y2xf.mjs → theme-7u5Qo3dF.mjs}

@@ -1,5 +1,5 @@
 import os from "node:os";
-import process from "node:process";
+import process$1 from "node:process";
 import tty from "node:tty";
 //#region node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 const ANSI_BACKGROUND_OFFSET = 10;
@@ -166,13 +166,13 @@ function assembleStyles() {
 const ansiStyles = assembleStyles();
 //#endregion
 //#region node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
 	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
 	const position = argv.indexOf(prefix + flag);
 	const terminatorPosition = argv.indexOf("--");
 	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-const { env: env$1 } = process;
+const { env: env$1 } = process$1;
 let flagForceColor;
 if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
 else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
@@ -205,7 +205,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
 	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
 	const min = forceColor || 0;
 	if (env$1.TERM === "dumb") return min;
-	if (process.platform === "win32") {
+	if (process$1.platform === "win32") {
 		const osRelease = os.release().split(".");
 		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
 		return 1;
@@ -403,6 +403,244 @@ Object.defineProperties(createChalk.prototype, styles);
 const chalk = createChalk();
 createChalk({ level: stderrColor ? stderrColor.level : 0 });
 //#endregion
+//#region src/rainbow.ts
+/**
+* The bright-tier spectrum: twelve Tailwind *-300 hues covering red through
+* fuchsia, every one ≥11:1 on black. The roll samples this pool by shuffle;
+* nothing outside it is ever painted.
+*/
+const RAINBOW_POOL = [
+	[
+		252,
+		165,
+		165
+	],
+	[
+		253,
+		186,
+		116
+	],
+	[
+		253,
+		230,
+		138
+	],
+	[
+		253,
+		224,
+		71
+	],
+	[
+		190,
+		242,
+		100
+	],
+	[
+		134,
+		239,
+		172
+	],
+	[
+		94,
+		234,
+		212
+	],
+	[
+		103,
+		232,
+		249
+	],
+	[
+		125,
+		211,
+		252
+	],
+	[
+		147,
+		197,
+		253
+	],
+	[
+		196,
+		181,
+		253
+	],
+	[
+		240,
+		171,
+		252
+	]
+];
+/**
+* Status tones in canonical on-screen order (row one left-to-right, then row
+* two): consecutive entries here are the pairs the "adjacent spans differ"
+* guarantee covers, including the accent→value step across the row boundary.
+*/
+const TONE_ORDER = [
+	"live",
+	"model",
+	"path",
+	"branch",
+	"accent",
+	"value",
+	"label",
+	"meta",
+	"ctxFill",
+	"success",
+	"plan",
+	"warn",
+	"error"
+];
+/** Parse a RAINBOW_SEED value: a non-negative decimal uint32, else nothing. */
+function parseRainbowSeed(value) {
+	if (value === void 0 || !/^\d{1,10}$/.test(value.trim())) return void 0;
+	const parsed = Number(value.trim());
+	return Number.isSafeInteger(parsed) ? parsed >>> 0 : void 0;
+}
+/**
+* One parsed `/rainbow` argument: empty means a fresh random roll; a
+* decimal uint32 pins that seed; anything else is a usage error.
+* @param argument - the raw text after `/rainbow`.
+* @returns `{ seed }`, `'random'`, or `'usage'`.
+*/
+function parseRainbowArgument(argument) {
+	const trimmed = argument.trim();
+	if (trimmed === "") return "random";
+	const parsed = parseRainbowSeed(trimmed);
+	return parsed === void 0 ? "usage" : { seed: parsed };
+}
+/** Deterministic 32-bit RNG (mulberry32) — one roll, one stream. */
+function mulberry32(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 | 0;
+		let t = Math.imul(state ^ state >>> 15, 1 | state);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Fisher–Yates shuffle over a copy, driven by the roll's RNG. */
+function shuffle(items, rng) {
+	const out = [...items];
+	for (let i = out.length - 1; i > 0; i -= 1) {
+		const j = Math.floor(rng() * (i + 1));
+		[out[i], out[j]] = [out[j], out[i]];
+	}
+	return out;
+}
+/** Approximate HSL hue of one RGB triple, degrees in [0, 360). */
+function hueOf([r, g, b]) {
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	if (max === min) return 0;
+	const span = max - min;
+	if (max === r) return (60 * (g - b) / span + 360) % 360;
+	if (max === g) return (60 * (b - r) / span + 120) % 360;
+	return (60 * (r - g) / span + 240) % 360;
+}
+/** A dark row tint for diff backgrounds: the hue at 22% strength over black. */
+function darkTint(hue) {
+	return [
+		Math.round(hue[0] * .22),
+		Math.round(hue[1] * .22),
+		Math.round(hue[2] * .22)
+	];
+}
+/** Readability anchors shared by every roll: captions, text, band stay calm. */
+const DIM = [
+	166,
+	163,
+	184
+];
+const TEXT = [
+	240,
+	238,
+	249
+];
+const BAND = [
+	46,
+	46,
+	52
+];
+/**
+* Build the roll for one seed: pure and deterministic, so tests pin exact
+* outcomes and RAINBOW_SEED reproduces a lucky launch exactly.
+* @param seed - the uint32 seed to roll from.
+* @returns the complete carnival roll.
+*/
+function rollRainbow(seed) {
+	const rng = mulberry32(seed);
+	const pool = shuffle(RAINBOW_POOL, rng);
+	const [brand, brandBright, brandMid, brandDeep, code, success, error, warn, addHue, delHue] = pool;
+	const palette = {
+		brand,
+		brandBright,
+		brandMid,
+		brandDeep,
+		dim: DIM,
+		success,
+		error,
+		warn,
+		text: TEXT,
+		code,
+		composerBand: BAND,
+		diffAdd: darkTint(addHue),
+		diffDel: darkTint(delHue),
+		diffAddFg: addHue,
+		diffDelFg: delHue,
+		surface: [
+			0,
+			0,
+			0
+		],
+		prompt: brandBright,
+		queued: warn,
+		steered: code
+	};
+	const ring = shuffle(RAINBOW_POOL, rng).slice(0, 4);
+	const offset = Math.floor(rng() * RAINBOW_POOL.length);
+	const toneColors = {};
+	TONE_ORDER.forEach((tone, index) => {
+		toneColors[tone] = pool[(offset + index) % pool.length];
+	});
+	return {
+		seed,
+		palette,
+		ring,
+		toneColors,
+		flowAnchors: [...RAINBOW_POOL].sort((a, b) => hueOf(a) - hueOf(b)),
+		flowPhaseMs: Math.floor(rng() * 2400)
+	};
+}
+/** The launch seed: RAINBOW_SEED when parseable, else a fresh random roll. */
+function launchSeed() {
+	const pinned = parseRainbowSeed(process.env.RAINBOW_SEED);
+	if (pinned !== void 0) return pinned;
+	return (Date.now() ^ Math.floor(Math.random() * 4294967296)) >>> 0;
+}
+let rolled;
+/** The memoized per-launch roll; computed once, stable for the whole run. */
+function rainbowRoll() {
+	if (rolled === void 0) rolled = rollRainbow(launchSeed());
+	return rolled;
+}
+/**
+* Replace the memoized roll: omit the seed for a fresh random one, or pass
+* a uint32 to pin it. `/rainbow` uses this so a mid-session reroll actually
+* recolors; {@link setTheme}(`'rainbow'`) must run afterwards so the
+* palette accessor picks the new values up.
+* @param seed - the seed to pin, or undefined for a new random roll.
+* @returns the roll now in force.
+*/
+function rerollRainbow(seed) {
+	rolled = rollRainbow(seed ?? (Date.now() ^ Math.floor(Math.random() * 4294967296)) >>> 0);
+	return rolled;
+}
+/** The current roll's seed as display copy (also the RAINBOW_SEED value). */
+function rainbowSeedLabel() {
+	return String(rainbowRoll().seed);
+}
+//#endregion
 //#region src/theme.ts
 /**
 * Terminal color tokens for the dsh TUI, mapped from the product design
@@ -410,13 +648,12 @@ createChalk({ level: stderrColor ? stderrColor.level : 0 });
 * (`packages/client/ui-theme/src/styles/design-platform.css`). Truecolor RGB
 * rides chalk, which degrades automatically on terminals without truecolor.
 *
-* Two palettes — `dark` (the default) and `light` — share the same token keys
-* with different values. Painters and the palette accessor read the ACTIVE
+* Three palettes — `dark` (the default), `light`, and `prismatic` (the
+* neon synthwave skin) — share the same token keys with different values.
+* Painters and the palette accessor read the ACTIVE
 * palette selected through {@link setTheme}, so a theme switch recolors every
-* painted surface on the next render without touching call sites. Raw token
-* consumers keep reading {@link TUI_RGB} (the dark values) until the
-* theme-aware integration replaces those call sites with
-* `inkColor(getPalette().token)`.
+* painted surface on the next render without touching call sites; consumers
+* read colors through {@link getPalette} or the painters below only.
 *
 * @module @deepseek-ai/dsh-tui/theme
 */
@@ -424,9 +661,43 @@ createChalk({ level: stderrColor ? stderrColor.level : 0 });
 const THEME_NAMES = [
 	"dark",
 	"light",
+	"prismatic",
+	"rainbow",
 	"auto"
 ];
 /**
+* Every theme's picker metadata in canonical order — the single source the
+* /theme panel rows derive from; {@link THEME_NAMES} stays the validation
+* list. Adding a theme means adding its palette plus one row here.
+*/
+const THEMES = [
+	{
+		id: "dark",
+		label: "dark",
+		description: "DeepSeek dark palette (default)"
+	},
+	{
+		id: "light",
+		label: "light",
+		description: "light palette for bright terminals"
+	},
+	{
+		id: "prismatic",
+		label: "prismatic",
+		description: "neon synthwave palette (violet/magenta/cyan)"
+	},
+	{
+		id: "rainbow",
+		label: "rainbow",
+		description: "randomized carnival palette (/rainbow to reroll)"
+	},
+	{
+		id: "auto",
+		label: "auto",
+		description: "follow the terminal; dark until detection lands"
+	}
+];
+/**
 * DeepSeek dark palette: the original TUI colors, one entry per
 * design-platform token in use. Keep names and values in sync with the CSS
 * custom properties cited inline.
@@ -497,13 +768,67 @@ const DARK_PALETTE = {
 		46,
 		48,
 		52
+	],
+	/** Diff added-line background — Codex's muted dark green tint (#213A2B). */
+	diffAdd: [
+		33,
+		58,
+		43
+	],
+	/** Diff removed-line background — Codex's muted dark red tint (#4A221D). */
+	diffDel: [
+		74,
+		34,
+		29
+	],
+	/** Diff added-line foreground — green-500, 5.4:1 on the diffAdd tint. */
+	diffAddFg: [
+		34,
+		197,
+		94
+	],
+	/** Diff removed-line foreground — red-400, 4.9:1 on the diffDel tint (error's red-500 sinks to 3.6:1 on it). */
+	diffDelFg: [
+		248,
+		113,
+		113
+	],
+	/** Terminal background this palette is designed against; row tints blend toward it. */
+	surface: [
+		0,
+		0,
+		0
+	],
+	/**
+	* The three prompt-row colors, one per delivery kind. They are the palette's
+	* own accents (bright brand, warning amber, violet) rather than fixed RGBs,
+	* and every row's bar is these colors laid over {@link surface}.
+	*/
+	prompt: [
+		103,
+		158,
+		254
+	],
+	queued: [
+		245,
+		158,
+		11
+	],
+	steered: [
+		167,
+		139,
+		250
 	]
 };
-/** Every palette by theme name; auto resolves through {@link resolveTheme}. */
+/**
+* Every STATIC palette by theme name; auto resolves through {@link resolveTheme}
+* and rainbow is rolled per launch ({@link rainbowRoll}), so neither lives
+* here — {@link setTheme} resolves both through the same key space.
+*/
 const PALETTES = {
 	dark: DARK_PALETTE,
 	light: {
-		/** Primary brand blue — unchanged, ≈4.9:1 AA on white. */
+		/** Primary brand blue — unchanged design-platform value; ≈4.2:1 on white, so bold/accent spans only (body-size brand text uses brandBright). */
 		brand: [
 			65,
 			118,
@@ -568,6 +893,170 @@ const PALETTES = {
 			229,
 			231,
 			235
+		],
+		/** Diff added-line background — GitHub's pastel green (#dafbe1), Codex's light pick. */
+		diffAdd: [
+			218,
+			251,
+			225
+		],
+		/** Diff removed-line background — GitHub's pastel red (#ffebe9), Codex's light pick. */
+		diffDel: [
+			255,
+			235,
+			233
+		],
+		/** Diff added-line foreground — green-800, 6.4:1 on the pastel tint (green-700 clears 4.5:1 by a hair). */
+		diffAddFg: [
+			22,
+			101,
+			52
+		],
+		/** Diff removed-line foreground — red-700, 5.6:1 on the pastel tint (error's red-600 is 3.9:1). */
+		diffDelFg: [
+			185,
+			28,
+			28
+		],
+		/** Terminal background this palette is designed against; row tints blend toward it. */
+		surface: [
+			255,
+			255,
+			255
+		],
+		/**
+		* Prompt-row colors deepened for white: the amber and violet the dark theme
+		* uses sit at the AA edge on their own pastel bars, so each kind carries a
+		* value that clears 4.5:1 both on the bar and on plain white.
+		*/
+		prompt: [
+			47,
+			76,
+			143
+		],
+		queued: [
+			124,
+			53,
+			10
+		],
+		steered: [
+			109,
+			40,
+			217
+		]
+	},
+	prismatic: {
+		/** Primary electric purple — violet-500 (#8B5CF6), 5.0:1 on black. */
+		brand: [
+			139,
+			92,
+			246
+		],
+		/** Live/streaming emphasis — neon fuchsia-300 (#F0ABFC), 11.9:1 on black. */
+		brandBright: [
+			240,
+			171,
+			252
+		],
+		/** Intermediate violet — violet-400 (#A78BFA), 7.7:1 on black. */
+		brandMid: [
+			167,
+			139,
+			250
+		],
+		/** Deep secondary chrome — violet-600 (#7C3AED), 3.7:1 on black (violet-700 misses 3:1). */
+		brandDeep: [
+			124,
+			58,
+			237
+		],
+		/** Muted captions — lavender gray (#A6A3B8), 8.6:1 on black. */
+		dim: [
+			166,
+			163,
+			184
+		],
+		/** Success green — unchanged from dark. */
+		success: [
+			34,
+			197,
+			94
+		],
+		/** Error red — unchanged from dark. */
+		error: [
+			239,
+			68,
+			68
+		],
+		/** Warning amber — unchanged from dark. */
+		warn: [
+			245,
+			158,
+			11
+		],
+		/** Default foreground text — white with a lavender cast (#F0EEF9). */
+		text: [
+			240,
+			238,
+			249
+		],
+		/** Inline/fenced code — neon cyan-300 (#67E8F9), 14.5:1 on black. */
+		code: [
+			103,
+			232,
+			249
+		],
+		/** Composer three-row band base — neutral dark gray, hue-free so wave tints read on it. */
+		composerBand: [
+			46,
+			46,
+			52
+		],
+		/** Diff added-line background — unchanged from dark. */
+		diffAdd: [
+			33,
+			58,
+			43
+		],
+		/** Diff removed-line background — unchanged from dark. */
+		diffDel: [
+			74,
+			34,
+			29
+		],
+		/** Diff added-line foreground — unchanged from dark. */
+		diffAddFg: [
+			34,
+			197,
+			94
+		],
+		/** Diff removed-line foreground — unchanged from dark. */
+		diffDelFg: [
+			248,
+			113,
+			113
+		],
+		/** Terminal background this palette is designed against; row tints blend toward it. */
+		surface: [
+			0,
+			0,
+			0
+		],
+		/** Prompt rows in the skin's own neon: fuchsia, amber, cyan. */
+		prompt: [
+			240,
+			171,
+			252
+		],
+		queued: [
+			245,
+			158,
+			11
+		],
+		steered: [
+			103,
+			232,
+			249
 		]
 	}
 };
@@ -578,12 +1067,13 @@ let activePalette = DARK_PALETTE;
 /**
 * Resolve a theme name to the palette actually in use. `auto` detection
 * (OSC 11 terminal background query) is a later enhancement; until it lands,
-* auto falls back to the dark palette.
+* auto falls back to the dark palette (prismatic and rainbow are always
+* explicit choices, never auto-resolved).
 * @param name - the requested theme name.
-* @returns 'dark' or 'light' — the palette key to paint with.
+* @returns 'dark', 'light', 'prismatic', or 'rainbow' — the palette key.
 */
 function resolveTheme(name) {
-	return name === "light" ? "light" : "dark";
+	return name === "light" ? "light" : name === "prismatic" ? "prismatic" : name === "rainbow" ? "rainbow" : "dark";
 }
 /**
 * Switch the active theme: painters and {@link getPalette} reflect the new
@@ -593,7 +1083,8 @@ function resolveTheme(name) {
 */
 function setTheme(name) {
 	activeName = name;
-	activePalette = PALETTES[resolveTheme(name)];
+	const resolved = resolveTheme(name);
+	activePalette = resolved === "rainbow" ? rainbowRoll().palette : PALETTES[resolved];
 }
 /**
 * The theme name in force. Returns the requested name ('auto' included) so
@@ -608,21 +1099,167 @@ function getPalette() {
 	return activePalette;
 }
 /**
-* Parse a persisted theme name: only 'light' and 'auto' survive; anything
-* else (missing, corrupt, or unknown) falls back to the dark default.
+* Parse a persisted theme name: only names in {@link THEME_NAMES} survive;
+* anything else (missing, corrupt, or unknown) falls back to the dark default.
 * @param value - the raw parsed JSON value (expected string).
 * @returns a valid theme name.
 */
 function parseThemeName(value) {
-	return value === "light" || value === "auto" ? value : "dark";
+	return typeof value === "string" && THEME_NAMES.includes(value) ? value : "dark";
 }
 /** Ink `color` string for one RGB triple. */
 function inkColor(triple) {
 	return `rgb(${triple[0]}, ${triple[1]}, ${triple[2]})`;
 }
+/**
+* Diff-line background as an Ink `backgroundColor` string, theme-aware and
+* depth-gated (the Codex diff renderer's rule): 16-color terminals paint
+* backgrounds from the saturated system palette, which drowns the text, so
+* they keep the foreground-only look; 256-color and truecolor terminals get
+* the palette's tint (chalk quantizes the RGB form down automatically).
+* @param token - which diff background, added or removed lines.
+* @returns the Ink background color, or undefined to paint foreground-only.
+*/
+function diffBackground(token) {
+	if (chalk.level < 2) return void 0;
+	return inkColor(activePalette[token]);
+}
+/** How far one prompt-row tint leans toward its color, over the surface. */
+const PROMPT_ROW_TINT = .22;
+/**
+* The color family one prompt row wears, chosen by how it was delivered: the
+* ordinary brand accent, the warning amber for a queued prompt, and the
+* palette's own third accent for a steered one. The bar behind it is derived
+* from that same color, so every theme — including a freshly rolled rainbow —
+* carries its own look instead of a fixed triple.
+* @param delivery - how the prompt was delivered; undefined is an ordinary one.
+* @returns the palette token whose color paints the row.
+*/
+function promptRowTokens(delivery) {
+	if (delivery === "queued") return { fg: "queued" };
+	if (delivery === "steered") return { fg: "steered" };
+	return { fg: "prompt" };
+}
+/**
+* Blended prompt-row background for one row color: the palette color laid
+* over the surface the palette is designed for (dark themes over black, light
+* over white), depth-gated exactly like {@link diffBackground} — a 16-color
+* terminal keeps the foreground-only look rather than painting a saturated
+* system background behind the text.
+* @param color - the row's palette token.
+* @returns the Ink background color, or undefined to paint foreground-only.
+*/
+function rowBackground(color) {
+	if (chalk.level < 2) return void 0;
+	const surface = activePalette.surface;
+	const tint = activePalette[color];
+	const blend = (index) => Math.round(surface[index] + (tint[index] - surface[index]) * PROMPT_ROW_TINT);
+	return inkColor([
+		blend(0),
+		blend(1),
+		blend(2)
+	]);
+}
+/**
+* The prismatic surface ring: four neon accents panels cycle through by
+* mount order (cyan → fuchsia → violet → lime), all ≥3:1 on black. Dark and
+* light ignore the ring — {@link surfaceAccent} falls back to the passed-in
+* base color so those themes stay pixel-identical.
+*/
+const ACCENT_RING = [
+	[
+		34,
+		211,
+		238
+	],
+	[
+		232,
+		121,
+		249
+	],
+	[
+		167,
+		139,
+		250
+	],
+	[
+		163,
+		230,
+		53
+	]
+];
+/**
+* The prismatic flow anchors: brand violet → neon fuchsia → neon cyan. All
+* three clear 4.5:1 on black, so a flowing foreground stays AA throughout
+* the oscillation (render/animations.ts walks the triangle).
+*/
+const FLOW_ANCHORS = [
+	[
+		139,
+		92,
+		246
+	],
+	[
+		232,
+		121,
+		249
+	],
+	[
+		34,
+		211,
+		238
+	]
+];
+/**
+* Whether the active theme is prismatic (the neon skin with surface rings
+* and flowing accents).
+*/
+function isPrismatic() {
+	return activeName === "prismatic";
+}
+/** Whether the active theme is rainbow (the per-launch carnival roll). */
+function isRainbow() {
+	return activeName === "rainbow";
+}
+/**
+* The flowing theme's anchor walk: prismatic rides the fixed violet→fuchsia→
+* cyan triangle; rainbow rides its rolled full-spectrum anchors with a random
+* phase; dark and light have no flow (undefined) and keep static accents.
+*/
+function themeFlow() {
+	if (isPrismatic()) return {
+		anchors: FLOW_ANCHORS,
+		phaseMs: 0
+	};
+	if (isRainbow()) {
+		const roll = rainbowRoll();
+		return {
+			anchors: roll.flowAnchors,
+			phaseMs: roll.flowPhaseMs
+		};
+	}
+}
+/**
+* The accent for one surface slot: prismatic rotates the {@link ACCENT_RING}
+* by slot index; every other theme gets the caller's base color back.
+* @param index - the slot's position in the mount-order sequence.
+* @param base - the color to use outside prismatic (the surface's usual one).
+* @returns the accent to paint the surface's border/title with.
+*/
+function surfaceAccent(index, base) {
+	if (isPrismatic()) {
+		const ring = ACCENT_RING;
+		return ring[(index % ring.length + ring.length) % ring.length];
+	}
+	if (isRainbow()) {
+		const ring = rainbowRoll().ring;
+		return ring[(index % ring.length + ring.length) % ring.length];
+	}
+	return base;
+}
 /** Paint muted captions, hints, and meta lines. */
 function dim(text) {
 	return chalk.rgb(...activePalette.dim)(text);
 }
 //#endregion
-export { inkColor as a, chalk as c, getTheme as i, dim as n, parseThemeName as o, getPalette as r, setTheme as s, THEME_NAMES as t };
+export { parseRainbowArgument as _, dim as a, rerollRainbow as b, inkColor as c, parseThemeName as d, promptRowTokens as f, themeFlow as g, surfaceAccent as h, diffBackground as i, isPrismatic as l, setTheme as m, THEMES as n, getPalette as o, rowBackground as p, THEME_NAMES as r, getTheme as s, FLOW_ANCHORS as t, isRainbow as u, rainbowRoll as v, chalk as x, rainbowSeedLabel as y };