@promptctl/rich-js 0.18.0 → 0.19.0

package/dist/themes/colorMath.js

@@ -0,0 +1,280 @@
+import { ColorDepth, ColorRgba, ColorSpec, blendRgb, contrastRatio, downgradeTable, relativeLuminance, resolveTerminal, SURFACE_BLACK, } from "../core/color.js";
+import { Oklch } from "../core/oklch.js";
+const LEVEL_STEP = 0.1;
+function rgbToHsl(c) {
+    const r = c.red / 255;
+    const g = c.green / 255;
+    const b = c.blue / 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    const d = max - min;
+    if (d === 0)
+        return { h: 0, s: 0, l };
+    const s = d / (l > 0.5 ? 2 - max - min : max + min);
+    let h;
+    if (max === r)
+        h = ((g - b) / d) % 6;
+    else if (max === g)
+        h = (b - r) / d + 2;
+    else
+        h = (r - g) / d + 4;
+    h = (h * 60 + 360) % 360;
+    return { h, s, l };
+}
+function clampChannel(v) {
+    // Float HSL math + Math.round can land at -1 or 256 at the boundaries; clamp
+    // so an invalid ColorRgba never escapes this function.
+    const r = Math.round(v);
+    return r < 0 ? 0 : r > 255 ? 255 : r;
+}
+function hslToRgb(hsl) {
+    const { h, s, l } = hsl;
+    if (s === 0) {
+        const v = clampChannel(l * 255);
+        return new ColorRgba(v, v, v);
+    }
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const hp = h / 60;
+    const x = c * (1 - Math.abs((hp % 2) - 1));
+    let r = 0, g = 0, b = 0;
+    if (hp < 1)
+        [r, g, b] = [c, x, 0];
+    else if (hp < 2)
+        [r, g, b] = [x, c, 0];
+    else if (hp < 3)
+        [r, g, b] = [0, c, x];
+    else if (hp < 4)
+        [r, g, b] = [0, x, c];
+    else if (hp < 5)
+        [r, g, b] = [x, 0, c];
+    else
+        [r, g, b] = [c, 0, x];
+    const m = l - c / 2;
+    return new ColorRgba(clampChannel((r + m) * 255), clampChannel((g + m) * 255), clampChannel((b + m) * 255));
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+/**
+ * Darken a color by N levels, where each level reduces HSL lightness by 10%.
+ * Negative levels lighten. Level 0 returns an equivalent triplet (after the
+ * RGB↔HSL roundtrip; values may differ by ±1 due to rounding).
+ */
+export function darken(color, levels) {
+    const hsl = rgbToHsl(color);
+    hsl.l = clamp01(hsl.l - LEVEL_STEP * levels);
+    return hslToRgb(hsl);
+}
+/**
+ * Lighten a color by N levels. Equivalent to `darken(color, -levels)`.
+ */
+export function lighten(color, levels) {
+    return darken(color, -levels);
+}
+/**
+ * Composite `fg` over `bg` with the given alpha (0..1). At alpha=0 returns bg;
+ * at alpha=1 returns fg.
+ */
+export function alphaBlend(fg, bg, alpha) {
+    return blendRgb(bg, fg, clamp01(alpha));
+}
+/**
+ * Pick a contrasting foreground (black or white) for a background, using the
+ * WCAG relative-luminance threshold of 0.179 (the perceptually correct cutoff
+ * where black and white are equally readable). A translucent `bg` is judged
+ * as drawn: composited over `substrate` (see `drawnBackground`).
+ */
+export function contrastFor(bg, substrate = SURFACE_BLACK) {
+    const lum = relativeLuminance(drawnBackground(bg, substrate));
+    return lum > 0.179
+        ? new ColorRgba(0, 0, 0)
+        : new ColorRgba(255, 255, 255);
+}
+// [LAW:one-way-deps] The WCAG measures live in core/color.ts, beside the
+// ColorTable whose `matchReadable` needs them to pick a drawn text colour, and
+// below the theme math here. Re-exported so this module stays the colour-math
+// surface.
+export { relativeLuminance, contrastRatio };
+// Iterations for the lightness bisection below. 20 resolves L to ~1e-6 — far
+// finer than 8-bit quantization or the eye.
+const CONTRAST_ITERS = 20;
+/**
+ * Return a foreground guaranteed to clear `minRatio` against `bg`, keeping the
+ * color *recognizably itself*. If the themed `fg` already passes it is returned
+ * untouched. Otherwise its OKLCH lightness is slid toward the pole that raises
+ * contrast — holding hue, and chroma where it stays in gamut (near the poles
+ * gamut clamping may reduce chroma, but hue is preserved) — until the ratio is
+ * met, so a blue on a dark-blue background becomes a lighter blue, not white.
+ * Only when no lightness of that hue can meet the ratio (a mid-toned
+ * background where even pure black-or-white tops out below the target) does it
+ * fall back to `contrastFor`'s black/white — the true maximum-contrast pick.
+ *
+ * A translucent `bg` is measured as it is drawn — composited over
+ * `substrate`, the SGR writer's black by default — and a translucent `fg` is
+ * then flattened over that drawn background, the order the writer composites
+ * in, so the ratio is measured on what the eye actually sees and the returned
+ * color is opaque.
+ *
+ * `drawnAt` is the depth the terminal will draw the pair at. At 256 colours
+ * the terminal rounds text and background independently, and two roundings
+ * can meet in the middle, so the ratio is measured on the drawn pair: a
+ * colour that loses the floor there is replaced by the nearest cube/grey entry
+ * that clears it (whose own rounding is itself). At ANSI the terminal draws
+ * each index in its own theme's colour, so the ratio is measured on
+ * `terminal`'s sixteen: a theme whose black is light and white dark (Rosé Pine
+ * Dawn) turns the nominal table's sides over. A replacement is the colour the
+ * writer emits as the index nearest `fg` that clears the floor as `terminal`
+ * draws it. Truecolor draws the colour chosen.
+ *
+ * [LAW:single-enforcer] The one place "is this text readable, and if not fix
+ * it" is decided. Callers route every fg/bg pair through here and the
+ * unreadable state never reaches output. [LAW:dataflow-not-control-flow] the
+ * function always runs; the measured ratio (data) decides how far the
+ * lightness moves — there is no caller-side "should I check contrast" branch.
+ */
+export function ensureContrast(fg, bg, minRatio = 4.5, // WCAG AA for normal text
+drawnAt = ColorDepth.TRUECOLOR, substrate = SURFACE_BLACK, terminal) {
+    const ground = drawnBackground(bg, substrate);
+    const chosen = ensureContrastToward(fg, ground, minRatio, contrastFor(ground));
+    // [LAW:dataflow-not-control-flow] The depth names the table the terminal
+    // draws from; every table is measured the same way.
+    const table = drawnTable(drawnAt, terminal);
+    if (table === undefined)
+        return chosen;
+    const shownBg = shownAs(table, ground);
+    if (contrastRatio(shownAs(table, chosen), shownBg) >= minRatio)
+        return chosen;
+    return table.written.get(table.shown.matchReadable(fg.compositeOver(ground), shownBg, minRatio));
+}
+/**
+ * `chosen` (composited opaque over `substrate`), or — when the depth the
+ * terminal draws at rounds it to a colour `accept` refuses — the colour the
+ * writer emits as the nearest entry `accept` takes. `accept` sees the
+ * candidate as drawn, and `drawn`, the same rounding for any other colour it
+ * measures against, so the caller states a floor once and it holds on the
+ * colours the terminal shows — at ANSI, `terminal`'s own sixteen, as
+ * `ensureContrast` measures there. Truecolor
+ * draws from no table, so a colour refused there has no replacement;
+ * `undefined` means nothing the depth draws is accepted.
+ *
+ * `ensureContrast` is this with a contrast ratio as the floor; this is for a
+ * floor that is not text on its background (an open state standing off every
+ * closed cell, two planes standing off each other).
+ */
+export function ensureDrawn(chosen, drawnAt, accept, substrate = SURFACE_BLACK, terminal) {
+    // The floor was measured on `chosen` composited over `substrate`, so that
+    // opaque colour is what is returned — never a translucent one a different
+    // ground would composite into a colour `accept` never saw.
+    const opaque = drawnBackground(chosen, substrate);
+    const table = drawnTable(drawnAt, terminal);
+    const drawn = (c) => shownAs(table, drawnBackground(c, substrate));
+    if (accept(drawn(opaque), drawn))
+        return opaque;
+    // [LAW:dataflow-not-control-flow] Truecolor draws from no table, so it has
+    // no candidates: a refusal there is `undefined` like any exhausted search.
+    const index = table?.shown.matchWhere(opaque, (entry) => accept(entry, drawn));
+    return index === undefined ? undefined : table.written.get(index);
+}
+/**
+ * The colour a ground is shown as at `drawnAt`: composited over `substrate`
+ * (the SGR writer's black by default), rounded to the index the writer emits
+ * at that depth, and shown as the terminal shows that index — at ANSI, in
+ * `terminal`'s own colour. The one account `ensureDrawn` and `ensureContrast`
+ * measure by, for a caller that measures a floor of its own.
+ */
+export function drawnColour(colour, drawnAt, substrate = SURFACE_BLACK, terminal) {
+    return shownAs(drawnTable(drawnAt, terminal), drawnBackground(colour, substrate));
+}
+/**
+ * An opaque colour as the terminal shows it: downgraded to the index the
+ * writer emits and drawn as the terminal draws that index.
+ * [LAW:one-source-of-truth] That rounding is `ColorSpec.downgrade`'s, the one
+ * `Style.drawnColors` writes; the tables here only list the candidates.
+ */
+function shownAs(table, opaque) {
+    return table === undefined ? opaque : ColorSpec.fromRgba(opaque).downgrade(table.depth).getTruecolor(table.terminal);
+}
+/**
+ * A background as it is drawn: composited over the surface beneath it. That
+ * surface is a fact about where the pair is drawn, so it arrives as a value:
+ * the SGR writer (`Style.toSgrCodes`) and the exports that picture its output
+ * composite over `SURFACE_BLACK`, the default here; a caller that composites
+ * its colours onto a different surface itself names that one.
+ * [LAW:no-silent-failure] A surface has nothing under it, so a translucent one
+ * has no drawn colour to offer; `compositeOver` would read its raw RGB as if
+ * it were opaque, so it is refused here rather than measured wrong.
+ * [LAW:one-source-of-truth] Text is chosen against the colour the surface will
+ * show — measuring the raw RGBA reads a colour that is drawn nowhere, and text
+ * that "clears" it can land below the floor. Opaque colours composite to
+ * themselves.
+ */
+function drawnBackground(bg, substrate) {
+    if (substrate.alpha !== 1) {
+        throw new RangeError(`a contrast substrate is the opaque surface under a translucent background; got ${substrate.hex}`);
+    }
+    return bg.compositeOver(substrate);
+}
+/**
+ * The table the terminal draws from at `drawnAt`. The 256-colour cube and
+ * grey ramp are fixed by xterm, so the colour written is the colour shown.
+ * ANSI 0–15 are the terminal theme's own: the writer still picks the index by
+ * the nominal table — the Windows console's at WINDOWS — and the terminal
+ * shows `terminal`'s colour there.
+ * Truecolor draws the chosen colour itself, as do the depths no table stands
+ * behind.
+ */
+function drawnTable(drawnAt, terminal) {
+    const drawnBy = resolveTerminal(terminal, drawnAt);
+    switch (drawnAt) {
+        case ColorDepth.EIGHT_BIT:
+            return { depth: drawnAt, terminal: drawnBy, written: downgradeTable(drawnAt), shown: downgradeTable(drawnAt) };
+        case ColorDepth.STANDARD:
+        case ColorDepth.WINDOWS:
+            return { depth: drawnAt, terminal: drawnBy, written: downgradeTable(drawnAt), shown: drawnBy.ansiColors };
+        case ColorDepth.TRUECOLOR:
+        case ColorDepth.DEFAULT:
+            return undefined;
+    }
+}
+/**
+ * `fg` held to `minRatio` on `bg` in truecolor, moving in lightness toward
+ * `toward` (black or white). `ensureContrast` moves toward the pole `bg`
+ * itself contrasts with; a colour that already has a side (a palette's
+ * `text-*` is its text, tinted) passes that side, since on a ground near the
+ * 0.179 cutoff both poles clear and only one also reads on everything else
+ * the colour is drawn on. Where `toward` cannot clear `minRatio` on `bg`,
+ * the floor wins over the side: the answer is `contrastFor(bg)`.
+ */
+export function ensureContrastToward(fg, bg, minRatio, toward) {
+    // Flatten translucency so the guarantee holds for the displayed color, not
+    // the raw bytes (e.g. a hand-written "#FFFFFF60" over a light surface).
+    const opaqueFg = fg.compositeOver(bg);
+    if (contrastRatio(opaqueFg, bg) >= minRatio)
+        return opaqueFg;
+    const lab = Oklch.fromRgba(opaqueFg);
+    // `toward` is black or white, the pole the lightness moves to.
+    const poleL = relativeLuminance(toward) > 0.179 ? 1 : 0;
+    // If even the pole of this hue can't reach the ratio, the hue physically
+    // can't — return the true maximum-contrast pick (pure black/white from
+    // contrastFor). The gamut-clamped OKLCH pole is only *near* b/w, so
+    // contrastFor is at least as strong and is the honest maximum.
+    const pole = new Oklch(poleL, lab.c, lab.h, lab.alpha).toRgba();
+    if (contrastRatio(pole, bg) < minRatio)
+        return contrastFor(bg);
+    // Bisect for the lightness nearest the original that still clears the ratio:
+    // the smallest perceptual change that achieves accessibility. Contrast is
+    // monotone in L over [lab.l, poleL] (everything below the crossing fails),
+    // so the search is well-posed.
+    let fail = lab.l;
+    let pass = poleL;
+    for (let i = 0; i < CONTRAST_ITERS; i++) {
+        const mid = (fail + pass) / 2;
+        const candidate = new Oklch(mid, lab.c, lab.h, lab.alpha).toRgba();
+        if (contrastRatio(candidate, bg) >= minRatio)
+            pass = mid;
+        else
+            fail = mid;
+    }
+    return new Oklch(pass, lab.c, lab.h, lab.alpha).toRgba();
+}

package/dist/themes/colorRef.d.ts

@@ -0,0 +1,36 @@
+import { type ColorRgba } from "../core/color.js";
+import type { Palette } from "./palette.js";
+/**
+ * A **color reference** is the one string form an author uses to name a
+ * concrete color: a palette variable name (`"primary"`, `"surface-active"`,
+ * `"text-primary"`) or a literal `#RRGGBB` / `#RRGGBBAA`.
+ *
+ * [LAW:parse-dont-validate] `resolveColorRef` is the single checkpoint that
+ * turns an untrusted reference string into a `ColorRgba`. Everything
+ * downstream — color math, `Style` construction, serialization — takes
+ * `ColorRgba` and therefore cannot ask again whether the name existed. There
+ * is no `isValidColorRef` companion, deliberately: a validator would hand back
+ * the same `string` it was given and every consumer would re-check.
+ *
+ * [LAW:no-silent-failure] A miss throws. An unknown palette name is a broken
+ * config, and the author needs to see which name and what was available — not
+ * a silently substituted default that makes the bar merely look wrong.
+ */
+export declare class ColorRefError extends Error {
+    readonly ref: string;
+    constructor(ref: string, detail: string, options?: ErrorOptions);
+}
+/**
+ * Resolve a color reference against `palette`.
+ *
+ * Accepting hex alongside names is what makes this **idempotent**:
+ * `resolveColorRef(p, resolveColorRef(p, r).hex)` equals
+ * `resolveColorRef(p, r)` for every `r` this function accepts. Callers
+ * therefore never branch on "is this a palette name or already a color" —
+ * they call it unconditionally on whatever the author wrote, whether that is
+ * `"surface-active"` or the output of a chain of color math.
+ * [LAW:dataflow-not-control-flow]
+ *
+ * @throws {ColorRefError} on malformed hex or an unknown palette name.
+ */
+export declare function resolveColorRef(palette: Palette, ref: string): ColorRgba;

package/dist/themes/colorRef.js

@@ -0,0 +1,78 @@
+import { ColorParseError, parseHexColor } from "../core/color.js";
+/**
+ * A **color reference** is the one string form an author uses to name a
+ * concrete color: a palette variable name (`"primary"`, `"surface-active"`,
+ * `"text-primary"`) or a literal `#RRGGBB` / `#RRGGBBAA`.
+ *
+ * [LAW:parse-dont-validate] `resolveColorRef` is the single checkpoint that
+ * turns an untrusted reference string into a `ColorRgba`. Everything
+ * downstream — color math, `Style` construction, serialization — takes
+ * `ColorRgba` and therefore cannot ask again whether the name existed. There
+ * is no `isValidColorRef` companion, deliberately: a validator would hand back
+ * the same `string` it was given and every consumer would re-check.
+ *
+ * [LAW:no-silent-failure] A miss throws. An unknown palette name is a broken
+ * config, and the author needs to see which name and what was available — not
+ * a silently substituted default that makes the bar merely look wrong.
+ */
+export class ColorRefError extends Error {
+    ref;
+    constructor(ref, detail, options) {
+        super(`color reference ${JSON.stringify(ref)} did not resolve — ${detail}`, options);
+        this.ref = ref;
+        this.name = "ColorRefError";
+    }
+}
+// A reference *shaped* like hex is resolved as hex; anything else is a palette
+// name. This is a lexical distinction with no overlap — palette variable names
+// never begin with `#` — so it is a parse, not a mode. A `#`-leading string
+// that is malformed hex fails loudly here rather than falling through to a
+// palette lookup that would report a confusing "unknown name" instead of
+// "malformed hex".
+const HEX_LEAD = "#";
+// Cap the "did you mean" list. Palettes carry ~150 variables; dumping all of
+// them buries the message. Nearby names are what a mistyped reference needs.
+const SUGGESTION_LIMIT = 8;
+/**
+ * Resolve a color reference against `palette`.
+ *
+ * Accepting hex alongside names is what makes this **idempotent**:
+ * `resolveColorRef(p, resolveColorRef(p, r).hex)` equals
+ * `resolveColorRef(p, r)` for every `r` this function accepts. Callers
+ * therefore never branch on "is this a palette name or already a color" —
+ * they call it unconditionally on whatever the author wrote, whether that is
+ * `"surface-active"` or the output of a chain of color math.
+ * [LAW:dataflow-not-control-flow]
+ *
+ * @throws {ColorRefError} on malformed hex or an unknown palette name.
+ */
+export function resolveColorRef(palette, ref) {
+    const trimmed = ref.trim();
+    if (trimmed.startsWith(HEX_LEAD)) {
+        try {
+            return parseHexColor(trimmed);
+        }
+        catch (cause) {
+            if (!(cause instanceof ColorParseError))
+                throw cause;
+            throw new ColorRefError(ref, cause.message, { cause });
+        }
+    }
+    const hit = palette.get(trimmed);
+    if (hit === undefined) {
+        throw new ColorRefError(ref, `no such variable in palette ${JSON.stringify(palette.name)}` +
+            suggest(palette, trimmed));
+    }
+    return hit;
+}
+// Names sharing a prefix or suffix with the miss — enough to catch the two
+// mistakes that actually happen (a wrong qualifier, `surface-active` vs
+// `surface-lighten`; a wrong root, `text-primary` vs `primary-text`) without
+// printing the whole palette.
+function suggest(palette, miss) {
+    const parts = miss.split("-");
+    const near = [...palette.vars.keys()]
+        .filter((name) => parts.some((part) => part !== "" && name.includes(part)))
+        .slice(0, SUGGESTION_LIMIT);
+    return near.length === 0 ? "" : `; did you mean: ${near.join(", ")}`;
+}

package/dist/themes/data/ansi-tables.d.ts

@@ -0,0 +1,14 @@
+import { type AnsiColorsData } from "./types.js";
+/**
+ * The VGA colours a terminal draws with no theme of its own: Rich's
+ * `DEFAULT_TERMINAL_THEME`, and what `textual-ansi` spells its palette in.
+ */
+export declare const VGA_ANSI: AnsiColorsData;
+/**
+ * The ANSI tables Textual draws named colours in for a theme that has no
+ * terminal scheme of its own: `MONOKAI` under a dark theme and `ALABASTER`
+ * under a light one (`ansi_theme_dark` / `ansi_theme_light` in Textual's
+ * `app.py`, values from its `_ansi_theme.py`).
+ */
+export declare const TEXTUAL_DARK_ANSI: AnsiColorsData;
+export declare const TEXTUAL_LIGHT_ANSI: AnsiColorsData;

package/dist/themes/data/ansi-tables.js

@@ -0,0 +1,49 @@
+import { STANDARD_TABLE } from "../../core/color.js";
+import { ANSI_SLOTS } from "./types.js";
+/**
+ * The VGA colours a terminal draws with no theme of its own: Rich's
+ * `DEFAULT_TERMINAL_THEME`, and what `textual-ansi` spells its palette in.
+ */
+export const VGA_ANSI = Object.fromEntries(ANSI_SLOTS.map((slot, n) => [slot, STANDARD_TABLE.get(n).hex]));
+/**
+ * The ANSI tables Textual draws named colours in for a theme that has no
+ * terminal scheme of its own: `MONOKAI` under a dark theme and `ALABASTER`
+ * under a light one (`ansi_theme_dark` / `ansi_theme_light` in Textual's
+ * `app.py`, values from its `_ansi_theme.py`).
+ */
+export const TEXTUAL_DARK_ANSI = {
+    black: "#1A1A1A",
+    red: "#F4005F",
+    green: "#98E024",
+    yellow: "#FD971F",
+    blue: "#9D65FF",
+    magenta: "#F4005F",
+    cyan: "#58D1EB",
+    white: "#C4C5B5",
+    brightBlack: "#625E4C",
+    brightRed: "#F4005F",
+    brightGreen: "#98E024",
+    brightYellow: "#E0D561",
+    brightBlue: "#9D65FF",
+    brightMagenta: "#F4005F",
+    brightCyan: "#58D1EB",
+    brightWhite: "#F6F6EF",
+};
+export const TEXTUAL_LIGHT_ANSI = {
+    black: "#000000",
+    red: "#AA3731",
+    green: "#448C27",
+    yellow: "#CB9000",
+    blue: "#325CC0",
+    magenta: "#7A3E9D",
+    cyan: "#0083B2",
+    white: "#F7F7F7",
+    brightBlack: "#777777",
+    brightRed: "#F05050",
+    brightGreen: "#60CB00",
+    brightYellow: "#FFBC5D",
+    brightBlue: "#007ACC",
+    brightMagenta: "#E64CE6",
+    brightCyan: "#00AACB",
+    brightWhite: "#F7F7F7",
+};

package/dist/themes/data/atom-one-dark.d.ts

@@ -0,0 +1,3 @@
+import type { ThemePaletteData } from "./types.js";
+declare const theme: ThemePaletteData;
+export default theme;

package/dist/themes/data/atom-one-dark.js

@@ -0,0 +1,177 @@
+const theme = {
+    name: "atom-one-dark",
+    dark: true,
+    // iTerm2-Color-Schemes "One Half Dark", a terminal port of Atom One
+    ansi: {
+        black: "#282C34",
+        red: "#E06C75",
+        green: "#98C379",
+        yellow: "#E5C07B",
+        blue: "#61AFEF",
+        magenta: "#C678DD",
+        cyan: "#56B6C2",
+        white: "#DCDFE4",
+        brightBlack: "#5D677A",
+        brightRed: "#E06C75",
+        brightGreen: "#98C379",
+        brightYellow: "#E5C07B",
+        brightBlue: "#61AFEF",
+        brightMagenta: "#C678DD",
+        brightCyan: "#56B6C2",
+        brightWhite: "#DCDFE4",
+    },
+    vars: {
+        "accent": "#A378C2",
+        "accent-darken-1": "#8E65AD",
+        "accent-darken-2": "#7A5299",
+        "accent-darken-3": "#674085",
+        "accent-lighten-1": "#B78BD6",
+        "accent-lighten-2": "#CC9FEC",
+        "accent-lighten-3": "#E2B3FF",
+        "accent-muted": "#4C425E",
+        "background": "#282C34",
+        "background-darken-1": "#181C23",
+        "background-darken-2": "#050A14",
+        "background-darken-3": "#000000",
+        "background-lighten-1": "#383C44",
+        "background-lighten-2": "#494D56",
+        "background-lighten-3": "#5B5F68",
+        "block-cursor-background": "#61AFEF",
+        "block-cursor-blurred-background": "#61AFEF4C",
+        "block-cursor-blurred-foreground": "#ABB2BF",
+        "block-cursor-foreground": "#FFFFFFDD",
+        "block-hover-background": "#FFFFFF19",
+        "boost": "#FFFFFF0A",
+        "boost-darken-1": "#E9E9E90A",
+        "boost-darken-2": "#D4D4D40A",
+        "boost-darken-3": "#BFBFBF0A",
+        "boost-lighten-1": "#FFFFFF0A",
+        "boost-lighten-2": "#FFFFFF0A",
+        "boost-lighten-3": "#FFFFFF0A",
+        "border": "#61AFEF",
+        "border-blurred": "#353B47",
+        "button-color-foreground": "#FFFFFFDD",
+        "button-foreground": "#ABB2BF",
+        "error": "#EF6262",
+        "error-darken-1": "#D84D50",
+        "error-darken-2": "#C1373E",
+        "error-darken-3": "#AA1F2E",
+        "error-lighten-1": "#FF7674",
+        "error-lighten-2": "#FF8B87",
+        "error-lighten-3": "#FFA09B",
+        "error-muted": "#643C41",
+        "footer-background": "#4F5666",
+        "footer-description-background": "#00000000",
+        "footer-description-foreground": "#ABB2BF",
+        "footer-foreground": "#ABB2BF",
+        "footer-item-background": "#00000000",
+        "footer-key-background": "#00000000",
+        "footer-key-foreground": "#A378C2",
+        "foreground": "#ABB2BF",
+        "foreground-darken-1": "#979DAA",
+        "foreground-darken-2": "#838A96",
+        "foreground-darken-3": "#707783",
+        "foreground-disabled": "#ABB2BF60",
+        "foreground-lighten-1": "#BFC6D3",
+        "foreground-lighten-2": "#D4DBE8",
+        "foreground-lighten-3": "#E9F0FE",
+        "foreground-muted": "#ABB2BF99",
+        "input-cursor-background": "#ABB2BF",
+        "input-cursor-foreground": "#282C34",
+        "input-selection-background": "#77C3FF66",
+        "link-background": "#00000000",
+        "link-background-hover": "#61AFEF",
+        "link-color": "#FFFFFFDD",
+        "link-color-hover": "#FFFFFFDD",
+        "markdown-h1-background": "#00000000",
+        "markdown-h1-color": "#61AFEF",
+        "markdown-h2-background": "#00000000",
+        "markdown-h2-color": "#61AFEF",
+        "markdown-h3-background": "#00000000",
+        "markdown-h3-color": "#61AFEF",
+        "markdown-h4-background": "#00000000",
+        "markdown-h4-color": "#ABB2BF",
+        "markdown-h5-background": "#00000000",
+        "markdown-h5-color": "#ABB2BF",
+        "markdown-h6-background": "#00000000",
+        "markdown-h6-color": "#ABB2BF99",
+        "panel": "#4F5666",
+        "panel-darken-1": "#3D4453",
+        "panel-darken-2": "#2C3342",
+        "panel-darken-3": "#1C2331",
+        "panel-lighten-1": "#616878",
+        "panel-lighten-2": "#737A8B",
+        "panel-lighten-3": "#868E9F",
+        "primary": "#61AFEF",
+        "primary-background": "#4F5B6A",
+        "primary-background-darken-1": "#3F4D5D",
+        "primary-background-darken-2": "#303F50",
+        "primary-background-darken-3": "#303F50",
+        "primary-background-lighten-1": "#5E6A77",
+        "primary-background-lighten-2": "#6E7884",
+        "primary-background-lighten-3": "#7D8791",
+        "primary-darken-1": "#489BD9",
+        "primary-darken-2": "#2C87C4",
+        "primary-darken-3": "#0074AF",
+        "primary-lighten-1": "#77C3FF",
+        "primary-lighten-2": "#8ED8FF",
+        "primary-lighten-3": "#A4EDFF",
+        "primary-muted": "#39536C",
+        "scrollbar": "#355674",
+        "scrollbar-active": "#61AFEF",
+        "scrollbar-background": "#181C23",
+        "scrollbar-background-active": "#181C23",
+        "scrollbar-background-hover": "#181C23",
+        "scrollbar-corner-color": "#181C23",
+        "scrollbar-hover": "#3C6589",
+        "secondary": "#C678DD",
+        "secondary-background": "#5B5567",
+        "secondary-background-darken-1": "#4D465A",
+        "secondary-background-darken-2": "#3F374D",
+        "secondary-background-darken-3": "#3F374D",
+        "secondary-background-lighten-1": "#6A6475",
+        "secondary-background-lighten-2": "#787382",
+        "secondary-background-lighten-3": "#87828F",
+        "secondary-darken-1": "#B064C7",
+        "secondary-darken-2": "#9B50B3",
+        "secondary-darken-3": "#873D9E",
+        "secondary-lighten-1": "#DB8CF2",
+        "secondary-lighten-2": "#F1A0FF",
+        "secondary-lighten-3": "#FFB5FF",
+        "secondary-muted": "#574266",
+        "success": "#62F062",
+        "success-darken-1": "#48DA4D",
+        "success-darken-2": "#29C438",
+        "success-darken-3": "#00AF22",
+        "success-lighten-1": "#7AFF76",
+        "success-lighten-2": "#91FF8A",
+        "success-lighten-3": "#A8FF9F",
+        "success-muted": "#396641",
+        "surface": "#3B414D",
+        "surface-active": "#484E5B",
+        "surface-darken-1": "#2A303B",
+        "surface-darken-2": "#1A202B",
+        "surface-darken-3": "#09101B",
+        "surface-lighten-1": "#4C525E",
+        "surface-lighten-2": "#5E6471",
+        "surface-lighten-3": "#707684",
+        "text": "#FFFFFFDD",
+        "text-accent": "#C2A5D6",
+        "text-disabled": "#FFFFFF60",
+        "text-error": "#F59797",
+        "text-muted": "#FFFFFF99",
+        "text-primary": "#96CAF4",
+        "text-secondary": "#D9A5E8",
+        "text-success": "#97F597",
+        "text-warning": "#E9CC92",
+        "warning": "#DDB25B",
+        "warning-darken-1": "#C79D47",
+        "warning-darken-2": "#B28A34",
+        "warning-darken-3": "#9C7721",
+        "warning-lighten-1": "#F4C66E",
+        "warning-lighten-2": "#FFDB82",
+        "warning-lighten-3": "#FFF096",
+        "warning-muted": "#5E543F",
+    },
+};
+export default theme;

package/dist/themes/data/atom-one-light.d.ts

@@ -0,0 +1,3 @@
+import type { ThemePaletteData } from "./types.js";
+declare const theme: ThemePaletteData;
+export default theme;