hextimator 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 0.1.0
+- initial release

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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.

package/README.md

@@ -0,0 +1,137 @@
+# hextimator
+
+<p align="center">
+    <picture>
+        <img src="https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/assets/gh-cover.webp?raw=true" alt="hextimator" width="500">
+    </picture>
+</p>
+
+One brand color in, full accessible theme out.
+
+- Input: any single color. Output: complete light + dark theme with accessibility guarantees (AAA contrast by default).
+- Works at runtime — built for multi-tenant apps that need per-brand themes on the fly.
+- Perceptually uniform (OKLCH) — blue and yellow palettes look equally balanced, unlike HSL-based generators.
+
+## Installation
+
+Add to your project:
+
+```bash
+npm i hextimator
+```
+
+Or quickly get a one-off theme:
+
+```bash
+npx hextimator "#ff6677"
+```
+
+## Quick start
+
+```typescript
+import { hextimate } from "hextimator";
+
+const theme = hextimate("#6A5ACD").format();
+```
+
+### With a preset
+
+Presets configure hextimator for a specific framework in one call:
+
+```typescript
+import { hextimate, presets } from "hextimator";
+
+// shadcn/ui — generates --background, --primary, --destructive, etc.
+const theme = hextimate("#6366F1")
+  .preset(presets.shadcn)
+  .format();
+```
+
+Presets set sensible defaults but you can override anything in `.format()`:
+
+```typescript
+const theme = hextimate("#6366F1")
+  .preset(presets.shadcn)
+  .format({ colors: "hsl-raw" }); // older shadcn format
+```
+
+See [Presets](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/presets.md) for the full list and how to create your own.
+
+## Two-step API: generate, then format
+
+hextimator separates **palette generation** (color math) from **formatting** (output shape). This lets you extend the palette before choosing how to serialize it.
+
+```typescript
+const theme = hextimate("#6A5ACD")
+  .format({ as: "css", colors: "oklch" });
+```
+
+### Output formats
+
+All formats return `{ light: { ... }, dark: { ... } }`.
+
+- **`"object"`** (default) — plain keys: `accent`, `accent-strong`, …
+- **`"css"`** — CSS custom properties: `--accent`, `--accent-strong`, …
+- **`"tailwind"`** — nested tokens: `{ accent: { DEFAULT, strong, … } }`
+- **`"tailwind-css"`** — `@theme` block with `--color-accent`, `--color-accent-strong`, …
+- **`"scss"`** — SCSS variables: `$accent`, `$accent-strong`, …
+- **`"json"`** — JSON string of the plain object
+
+### Color value formats
+
+| `colors` | Example output |
+|---|---|
+| `"hex"` (default) | `"#6a5acd"` |
+| `"oklch"` | `"oklch(0.54 0.18 276)"` |
+| `"oklch-raw"` | `"0.54 0.18 276"` |
+| `"rgb"` | `"rgb(106, 90, 205)"` |
+| `"rgb-raw"` | `"106 90 205"` |
+| `"hsl"` | `"hsl(248, 53%, 58%)"` |
+| `"hsl-raw"` | `"248 53% 58%"` |
+| `"p3"` | `"color(display-p3 0.39 0.34 0.79)"` |
+| `"p3-raw"` | `"0.39 0.34 0.79"` |
+
+### Flexible input
+
+```typescript
+hextimate("#FF6666");            // hex string
+hextimate("rgb(255, 102, 102)"); // CSS function
+hextimate([255, 102, 102]);      // RGB tuple
+hextimate(0xff6666);             // numeric hex
+```
+
+> **Note on alpha**: Alpha values are intentionally ignored — `rgba(255, 0, 0, 0.5)` is treated as fully opaque `rgb(255, 0, 0)`. Alpha tokens undermine accessibility guarantees because contrast ratios depend on the background, which hextimator does not control.
+
+## How it works
+
+1. **Parse** any color input into a normalized `Color` object.
+2. **Convert** to OKLCH (perceptual color space) so lightness and chroma adjustments look uniform across hues.
+3. **Generate** accent, base, and semantic color scales — each with DEFAULT, strong, weak, and foreground variants.
+4. **Gamut-map** back to sRGB via binary-search chroma reduction (preserves lightness and hue).
+5. **Format** into your chosen output (CSS vars, Tailwind, SCSS, JSON, or plain object).
+
+## Utilities
+
+hextimator also exports its parsing and conversion functions for standalone use:
+
+```typescript
+import { parseColor, convertColor } from "hextimator";
+
+const color = parseColor("rgb(255, 102, 102)");
+const oklch = convertColor(color, "oklch");
+```
+
+## Documentation
+
+- [Extending the palette](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/extending-the-palette.md) — `addRole`, `addVariant`, `addToken`
+- [Presets](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/presets.md) — drop-in configs for shadcn/ui, or create your own
+- [Multiple themes](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/multiple-themes.md) — dynamic theming and `.fork()`
+- [Customization](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/customization.md) — generation and format options reference
+- [Color vision deficiency](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/color-vision-deficiency.md) — simulate and adapt for CVD
+- [React](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/react.md) — `useHextimator` hook, provider, dark mode strategies
+- [Tailwind CSS v4](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/tailwind.md) — setup and usage with Tailwind
+- [Real-world examples](https://github.com/fgrgic/hextimator/blob/main/packages/hextimator/docs/examples.md) — shadcn/ui, Stripe, Slack configurations
+
+## Contributing
+
+Issues and PRs are welcome at [github.com/fgrgic/hextimator](https://github.com/fgrgic/hextimator/issues).

package/dist/HextimatePaletteBuilder-BzrgFryu.d.mts

@@ -0,0 +1,540 @@
+/** A color in the sRGB color space. */
+interface RGB {
+    readonly space: 'srgb';
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly alpha: number;
+}
+/** A color in the HSL color space. */
+interface HSL {
+    readonly space: 'hsl';
+    readonly h: number;
+    readonly s: number;
+    readonly l: number;
+    readonly alpha: number;
+}
+/** A color in the OKLCH color space. */
+interface OKLCH {
+    readonly space: 'oklch';
+    readonly l: number;
+    readonly c: number;
+    readonly h: number;
+    readonly alpha: number;
+}
+/** A color in the OKLab color space. */
+interface OKLab {
+    readonly space: 'oklab';
+    readonly l: number;
+    readonly a: number;
+    readonly b: number;
+    readonly alpha: number;
+}
+/** A color in the linear RGB color space. */
+interface LinearRGB {
+    readonly space: 'linear-rgb';
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly alpha: number;
+}
+/** A color in the Display P3 color space (wide gamut). */
+interface DisplayP3 {
+    readonly space: 'display-p3';
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly alpha: number;
+}
+/** A color in any supported color space. */
+type Color = RGB | HSL | OKLCH | OKLab | LinearRGB | DisplayP3;
+/** A color in a specific color space, strongly typed. */
+type ColorInSpace<S extends Color['space']> = Extract<Color, {
+    space: S;
+}>;
+/** The name of a color space, e.g. "srgb", "hsl", "oklch". */
+type ColorSpace = Color['space'];
+/** "FF6666", "#FF6666", "0xFF6666", "#F66" with optional alpha. */
+type HexString = string;
+/** e.g. `rgb(255, 102, 102)`, `rgba(255, 102, 102, 0.5)`. */
+type CSSColorString = string;
+/** Loose tuple: [255, 102, 102], [255, 102, 102, 0.5] */
+type ColorTuple = readonly [number, number, number, number?];
+/**
+ * Any supported color input: hex string, CSS function string, RGB tuple, numeric hex, or a parsed `Color` object.
+ *
+ * @example
+ * "#FF6666"
+ * "rgb(255, 102, 102)"
+ * [255, 102, 102]
+ * 0xFF6666
+ */
+type ColorInput = HexString | CSSColorString | ColorTuple | Color | number;
+/**
+ * Per-theme adjustments for lightness and chroma.
+ */
+interface ThemeAdjustments {
+    /**
+     * Absolute OKLCH lightness for this theme (0–1).
+     *
+     * Default: 0.7 for light, 0.6 for dark.
+     */
+    lightness?: number;
+    /**
+     * Maximum chroma for accent/semantic colors in this theme.
+     * Colors with higher chroma will be clamped to this value.
+     */
+    maxChroma?: number;
+    /**
+     * Minimum WCAG contrast ratio for this theme.
+     * Overrides the global `minContrastRatio` for this theme only.
+     *
+     * - `"AAA"` → 7
+     * - `"AA"` → 4.5
+     * - any number → exact ratio
+     */
+    minContrastRatio?: 'AAA' | 'AA' | number;
+    /**
+     * Maximum chroma for the baseline colors (base, strong, weak) in this theme.
+     * Overrides the global `baseMaxChroma` for this theme only.
+     */
+    baseMaxChroma?: number;
+    /**
+     * Maximum chroma for foreground colors in this theme.
+     * Overrides the global `foregroundMaxChroma` for this theme only.
+     */
+    foregroundMaxChroma?: number;
+}
+/**
+ * Options that affect color generation (the math)
+ */
+interface HextimateGenerationOptions {
+    /**
+     * Preferred base color for dark and light mode.
+     * It will be used as a baseline to generate the rest of base colors (strong, weak).
+     * If not provided, it will be derived from the main input color with very low chroma.
+     *
+     * Takes precedence over `baseHueShift` when both are set.
+     */
+    baseColor?: ColorInput;
+    /**
+     * Rotate the base color's hue relative to the accent color (in degrees).
+     *
+     * Examples: 180 for complementary, 30 for analogous, -30 for the other direction.
+     *
+     * Ignored when an explicit `baseColor` is provided.
+     *
+     * Default: 0 (same hue as the accent).
+     */
+    baseHueShift?: number;
+    /**
+     * Semantic colors to use for the theme
+     * If not provided, they will be generated from the provided main color,
+     * and the semantic color ranges.
+     */
+    semanticColors?: {
+        positive?: ColorInput;
+        negative?: ColorInput;
+        warning?: ColorInput;
+    };
+    /**
+     * Invert the hue used for the accent color in dark mode.
+     * Uses base hue as accent, and accent hue as base.
+     * Only has effect if `baseColor` is provided alongside the main accent color
+     *
+     * Default: false.
+     */
+    invertDarkModeBaseAccent?: boolean;
+    /**
+     * Degree ranges for the semantic colors.
+     * Determines where to look for "green", "red", "yellow" in the color space.
+     * If not provided, the default ranges will be used:
+     * - positive: [90, 150]   greens
+     * - negative: [345, 15]   reds
+     * - warning: [35, 55]    ambers
+     */
+    semanticColorRanges?: {
+        positive?: [number, number];
+        negative?: [number, number];
+        warning?: [number, number];
+    };
+    /**
+     * Maximum chroma for the baseline colors (base, strong, weak).
+     * Higher values will produce more colorful baseline colors, lower values will produce more gray baseline colors.
+     *
+     * Default: 0.01.
+     */
+    baseMaxChroma?: number;
+    /**
+     * Maximum chroma for all the foreground colors (e.g. base-accent-foreground)
+     * Higher values will produce more colorful foreground colors, lower values will produce more gray foreground colors.
+     *
+     * Default: 0.01.
+     */
+    foregroundMaxChroma?: number;
+    /**
+     * Per-theme adjustments for the light theme.
+     */
+    light?: ThemeAdjustments;
+    /**
+     * Per-theme adjustments for the dark theme.
+     */
+    dark?: ThemeAdjustments;
+    /**
+     * Minimum WCAG contrast ratio between non-foreground variants and the
+     * foreground variant.
+     *
+     * - `"AAA"` (default) → 7
+     * - `"AA"` → 4.5
+     * - any number → exact ratio (e.g. 3 for large text)
+     */
+    minContrastRatio?: 'AAA' | 'AA' | number;
+    /**
+     * Shift the hue (in degrees) from variant to variant.
+     *
+     * - Positive value: strong-side variants shift toward higher hues,
+     *   weak-side variants shift toward lower hues.
+     * - Negative value: flips the direction.
+     * - Each successive variant on a side shifts by an additional step
+     *   (e.g. hueShift: 5 → strong +5°, stronger +10°, weak −5°, weaker −10°).
+     *
+     * Clamped to `360 / (totalVariants + 1)` so the palette never wraps
+     * past a full rotation.
+     *
+     * Default: 0 (no hue shift).
+     */
+    hueShift?: number;
+}
+/**
+ * Options that affect output formatting (serialization)
+ */
+interface HextimateFormatOptions {
+    /**
+     * Rename roles in the output token keys.
+     * Internal name → your custom name.
+     *
+     * Examples:
+     * - base: "bg"
+     * - accent: "button"
+     * - positive: "success"
+     * - negative: "error"
+     * - warning: "warning"
+     *
+     * If not provided, the default role names will be used.
+     * The default role names are:
+     * - base: "base"
+     * - accent: "accent"
+     * - positive: "positive"
+     * - negative: "negative"
+     * - warning: "warning"
+     */
+    roleNames?: Record<string, string>;
+    /**
+     * Rename variant suffixes in the output token keys.
+     * Internal name → your custom name.
+     *
+     * Examples:
+     * - DEFAULT: "secondary"
+     * - strong: "primary"
+     * - weak: "tertiary"
+     * - foreground: "text"
+     */
+    variantNames?: Record<string, string>;
+    /**
+     * Separator to use between the role and the variant in the output token keys.
+     * If not provided, the default separator will be used.
+     * The default separator is: "-"
+     *
+     * Use "_" for "base_strong", "/" for "base/strong", etc.
+     */
+    separator?: string;
+    /**
+     * Output format.
+     * - "object" (default): { base: "#f2eee8", "base-strong": "#d4cfc8", ...}
+     * - "css": { "--base": "#f2eee8", "--base-strong": "#d4cfc8", ...}
+     * - "tailwind": { base: { DEFAULT: "#f2eee8", strong: "#d4cfc8", weak: "#faf8f6" } }
+     * - "scss": { $base: "#f2eee8", $base-strong: "#d4cfc8", ...}
+     * - "json": '{ "base": "#f2eee8", "base-strong": "#d4cfc8", ...}'
+     * - "tailwind-css": '@theme { --color-base: #f2eee8; --color-base-strong: #d4cfc8; ... }'
+     */
+    as?: 'object' | 'css' | 'tailwind' | 'tailwind-css' | 'scss' | 'json';
+    /**
+     * How color values are serialized in the output.
+     *
+     * - "hex" (default) → "#f2eee8"
+     * - "hsl"           → "hsl(30, 10%, 94%)"
+     * - "hsl-raw"       → "30 10% 94%"            (shadcn / CSS variable style)
+     * - "oklch"         → "oklch(0.96 0.01 70)"
+     * - "oklch-raw"     → "0.96 0.01 70"
+     * - "p3"            → "color(display-p3 0.94 0.93 0.91)"  (wide gamut)
+     * - "p3-raw"        → "0.94 0.93 0.91"
+     * - "rgb"           → "rgb(242, 238, 232)"
+     * - "rgb-raw"       → "242 238 232"
+     */
+    colors?: ColorFormat;
+}
+/**
+ * Combined options for the convenience API.
+ * Allows passing both generation and format options in one call.
+ */
+type HextimateOptions = HextimateGenerationOptions & HextimateFormatOptions;
+/** How color values are serialized in the output (e.g. "hex", "rgb", "oklch", "hsl", "p3", and their "-raw" variants). */
+type ColorFormat = 'hex' | 'hsl' | 'hsl-raw' | 'oklch' | 'oklch-raw' | 'p3' | 'p3-raw' | 'rgb' | 'rgb-raw';
+
+type CVDType = 'protanopia' | 'deuteranopia' | 'tritanopia' | 'achromatopsia';
+
+type FlatTokenMap = Record<string, string>;
+type NestedTokenMap = Record<string, Record<string, string>>;
+type FormatResult = FlatTokenMap | NestedTokenMap | string;
+
+/**
+ * A reusable preset that configures the palette builder with
+ * framework-specific roles, tokens, and format defaults.
+ *
+ * Presets are data-only objects — no circular dependencies, fully serializable.
+ *
+ * @example
+ * import { hextimate, presets } from 'hextimator';
+ *
+ * const theme = hextimate('#6366F1')
+ *   .preset(presets.shadcn)
+ *   .format();
+ */
+interface HextimatePreset {
+    /** Generation options (contrast, hue shifts, lightness, chroma). Applied before roles/variants/tokens. */
+    generation?: HextimateGenerationOptions;
+    /** Extra roles to add to the palette (each generates DEFAULT, strong, weak, foreground variants). */
+    roles?: Array<{
+        name: string;
+        color: ColorInput | DerivedToken;
+    }>;
+    /** Extra variants to add across all roles. */
+    variants?: Array<{
+        name: string;
+        placement: VariantPlacement;
+    }>;
+    /** Standalone tokens derived from existing palette values or explicit colors. */
+    tokens?: Array<{
+        name: string;
+        value: TokenValue;
+    }>;
+    /** Default format options. Can be overridden in `.format()`. */
+    format?: HextimateFormatOptions;
+}
+
+/** The result of formatting a palette, containing both light and dark theme tokens. */
+interface HextimateResult<F = FormatResult> {
+    light: F;
+    dark: F;
+}
+/**
+ * Where to place a new variant relative to existing ones.
+ * - `{ from: "strong" }` — one step past the named variant (redistributes to respect contrast)
+ * - `{ from: "weak", chroma: -0.02 }` — one step past weak, with a chroma offset
+ * - `{ between: ["DEFAULT", "weak"] }` — midpoint between two variants
+ */
+type VariantPlacement = {
+    from: string;
+    emphasis?: number;
+    chroma?: number;
+    hue?: number;
+} | {
+    between: [string, string];
+};
+/**
+ * A token derived from an existing role+variant, with optional offsets.
+ *
+ * `emphasis` is theme-aware: positive = more contrast with background,
+ * negative = softer/closer to background. It flips direction automatically
+ * between light and dark themes, so you never need per-theme splits for
+ * simple contrast adjustments.
+ *
+ * @example
+ * { from: "base.weak", lightness: -0.05 }
+ * { from: "accent", hue: -20 }
+ * { from: "base", emphasis: 0.12 }
+ * { from: "base.foreground", emphasis: -0.2 }
+ */
+interface DerivedToken {
+    from: string;
+    emphasis?: number;
+    lightness?: number;
+    chroma?: number;
+    hue?: number;
+}
+/**
+ * Value for a standalone token: a raw color, a derived reference, or per-theme values.
+ *
+ * @example
+ * "#FF6600"
+ * { from: "accent", lightness: +0.1 }
+ * { light: { from: "base.weak", lightness: -0.05 }, dark: { from: "base.weak", lightness: +0.05 } }
+ */
+type TokenValue = ColorInput | DerivedToken | {
+    light: DerivedToken | ColorInput;
+    dark: DerivedToken | ColorInput;
+};
+/**
+ * Palette builder.
+ *
+ * Supports adding roles, variants, and standalone tokens, as well as simulating and adapting for CVD.
+ * All operations are recorded and replayed in order on fork, ensuring consistent results.
+ * The internal palette is stored in a raw form with OKLCH color objects, allowing for precise adjustments and transformations.
+ */
+declare class HextimatePaletteBuilder {
+    private lightPalette;
+    private darkPalette;
+    private readonly inputColor;
+    private readonly options;
+    private readonly operations;
+    private readonly standaloneTokens;
+    private readonly weakSideVariants;
+    private readonly strongSideVariants;
+    private readonly betweenVariants;
+    private presetFormatDefaults?;
+    constructor(color: Color, options?: HextimateGenerationOptions);
+    /**
+     * Adds a custom role with given name and color.
+     * The color is expanded into a full scale and added to both light and dark palettes.
+     *
+     * The color can be a direct color value or a derived token referencing an existing role.
+     *
+     * e.g. `addRole('cta', '#ff0066')` adds a "cta" role with the specified hue as the base.
+     * `addRole('cta', { from: 'accent', hue: 180 })` adds a "cta" role with a complementary hue to accent.
+     *
+     * @param name Role name (e.g. "cta", "banner")
+     * @param color Base color or derived token for the role
+     */
+    addRole(name: string, color: ColorInput | DerivedToken): this;
+    /**
+     * Adds a variant to all roles, derived from an existing variant or placed between two variants.
+     *
+     * e.g. `addVariant('placeholder', { from: 'weak' })` adds a "placeholder" variant one step past "weak" across all roles and themes.
+     * `addVariant('highlight', { between: ['DEFAULT', 'strong'] })` adds a "highlight" variant that is exactly between "DEFAULT" and "strong" across all roles and themes.
+     *
+     * @param name Variant name (e.g. "placeholder", "highlight")
+     * @param placement Placement of the variant, either `{ from: 'weak' }` or `{ between: ['DEFAULT', 'strong'] }`
+     */
+    addVariant(name: string, placement: VariantPlacement): this;
+    /**
+     * Adds a standalone/one-off token that doesn't fit the role+variant structure.
+     * The value can be a direct color, a derived token based on an existing role+variant, or an object specifying different values for light and dark themes.
+     *
+     * e.g. `addToken('brand', '#3a86ff')` adds a "brand" token with the specified color in both themes.
+     * `addToken('brand', { light: '#3a86ff', dark: '#ff0066' })` adds a "brand" token with different colors in light and dark themes.
+     *
+     * It can also be used to override specific tokens after generation.
+     * `addToken('base-strong', '#ff0066')` overrides the automatically generated "base-strong" variant with a custom color.
+     *
+     * @param name Token name (e.g. "brand", "logo")
+     * @param value Token value, which can be an exact color, or derived from an existing role+variant.
+     */
+    addToken(name: string, value: TokenValue): this;
+    /**
+     * Applies a preset that configures roles, tokens, and format defaults
+     * for a specific framework or convention (e.g. shadcn/ui).
+     *
+     * Preset format defaults are used as a base in `.format()` — any options
+     * you pass to `.format()` will override the preset's defaults.
+     *
+     * @example
+     * import { hextimate, presets } from 'hextimator';
+     *
+     * const theme = hextimate('#6366F1')
+     *   .preset(presets.shadcn)
+     *   .format();
+     *
+     * // Override preset's color format:
+     * const theme = hextimate('#6366F1')
+     *   .preset(presets.shadcn)
+     *   .format({ colors: 'hsl-raw' });
+     */
+    preset(preset: HextimatePreset): this;
+    /**
+     *
+     * Simulates how the palette would look for a given type and severity of CVD.
+     * This is a destructive operation that permanently alters the palette, but can be useful for testing and previewing.
+     *
+     * It should not be used to generate the final output for users with CVD. For that, use `adaptFor` instead.
+     *
+     * e.g. `simulate('deuteranopia', 0.5)` simulates moderate deuteranopia, allowing you to see how the colors would appear to users with that condition.
+     * @param type Type of CVD to simulate (e.g. "protanopia", "deuteranopia", "tritanopia")
+     * @param severity Severity of the CVD simulation, from 0 (no effect) to 1 (full simulation). Defaults to 1 for a complete simulation.
+     */
+    simulate(type: CVDType, severity?: number): this;
+    /**
+     * Adapts the palette for a given type and severity of CVD,
+     * altering the colors to improve accessibility while maintaining as much of the original intent as possible.
+     *
+     * To preview how the original palette would appear to users with CVD, use `simulate`.
+     *
+     * A typical use case would be to generate a normal palette, then fork it and adapt the fork for CVD.
+     * Then you can also preview by chaining `adaptFor` and `simulate`
+     *
+     * e.g.
+     * ```ts
+     * const normalTheme = hextimate('#ff6600');
+     * const cvdTheme = normalTheme.fork().adaptFor('deuteranopia');
+     * const simulatedCVD = normalTheme.fork().simulate('deuteranopia');
+     * ````
+     *
+     * @param type Type of CVD to adapt for (e.g. "protanopia", "deuteranopia", "tritanopia")
+     * @param severity Severity of the CVD adaptation, from 0 (no change) to 1 (full adaptation). Defaults to 1 for a complete adaptation.
+     */
+    adaptFor(type: CVDType, severity?: number): this;
+    /**
+     * Creates a new builder instance with the same operations history, allowing you to generate a related palette with a different base color or options.
+     *
+     * e.g. `fork('#ff6677')` creates a new builder with the same
+     * roles, variants, tokens, and adjustments, but based on a different input color.
+     *
+     * `fork({ light: { lightness: 0.8 } })` creates a new builder with the same color but different light theme adjustments.
+     *
+     * @param colorOrOptions Either a new base color for the palette, or an object with new generation options to override (e.g. light/dark adjustments, hue shift, contrast ratio).
+     * @param maybeOptions If the first argument is a color, this can be an optional second argument with generation options to override.
+     * @returns A new builder instance with the same operations history but different base color and/or options.
+     */
+    fork(colorOrOptions?: ColorInput | Partial<HextimateGenerationOptions>, maybeOptions?: Partial<HextimateGenerationOptions>): HextimatePaletteBuilder;
+    /**
+     * Serializes the palette into the chosen output format.
+     *
+     * When a preset has been applied, its format options are used as defaults.
+     * Any options passed here override the preset's defaults.
+     *
+     * @param options Format options controlling output shape (`as`), color serialization (`colors`), role/variant renaming, and separator.
+     */
+    format(options: HextimateFormatOptions & {
+        as: 'tailwind';
+    }): HextimateResult<NestedTokenMap>;
+    format(options: HextimateFormatOptions & {
+        as: 'json' | 'tailwind-css';
+    }): HextimateResult<string>;
+    format(options: HextimateFormatOptions & {
+        as: 'object' | 'css' | 'scss';
+    }): HextimateResult<FlatTokenMap>;
+    format(options?: HextimateFormatOptions): HextimateResult;
+    private applyRole;
+    private applyVariant;
+    private applyToken;
+    private resolveStandaloneTokens;
+    private resolveTokenValue;
+    private resolveTokenSingle;
+    private isDerivedToken;
+    private resolveDerivedToken;
+    private resolveTokenValueWithChain;
+    private resolveTokenSingleWithChain;
+    private getSideVariantsFor;
+    private redistributeAllScales;
+    /**
+     * Distributes variants evenly between DEFAULT and the lightness boundary.
+     * Uses (i+1)/(n+1) spacing so variants never sit exactly at the boundary,
+     * preserving AAA contrast margin.
+     */
+    private redistributeVariants;
+    private recomputeBetweenVariants;
+    private computeBeyondVariant;
+    private computeBetweenVariant;
+    private resolvedOptions;
+}
+
+export { type Color as C, type DerivedToken as D, type FlatTokenMap as F, type HextimatePreset as H, type NestedTokenMap as N, type OKLCH as O, type ThemeAdjustments as T, type VariantPlacement as V, type CVDType as a, type ColorSpace as b, type ColorInSpace as c, type ColorInput as d, type HextimateGenerationOptions as e, HextimatePaletteBuilder as f, type FormatResult as g, type HextimateFormatOptions as h, type HextimateOptions as i, type HextimateResult as j, type TokenValue as k };