color-value-tools 1.2.0 → 1.2.2

package/dist/esm/internal/named-colors.d.ts

@@ -0,0 +1 @@
+export declare const NAMED_COLORS: Record<string, string>;

package/dist/esm/internal/named-colors.js

@@ -0,0 +1,162 @@
+// CSS named colors (CSS Color Module Level 4).
+export const NAMED_COLORS = {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgreen: '#006400',
+    darkgrey: '#a9a9a9',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkslategrey: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    gold: '#ffd700',
+    goldenrod: '#daa520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    grey: '#808080',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavender: '#e6e6fa',
+    lavenderblush: '#fff0f5',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgray: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightgrey: '#d3d3d3',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370db',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#db7093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#ff0000',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32',
+    // 'transparent' is the only CSS-wide keyword with an actual fixed color (fully
+    // transparent black) — normalizeColor() special-cases it before ever reaching
+    // this table (see the `str === 'transparent'` check), so this entry only
+    // matters for getColorType()/toNearestNamedColor(), which read the table
+    // directly. 'currentcolor'/'inherit'/'initial'/'unset' are deliberately NOT
+    // listed here: none of them has a color value of their own (they only resolve
+    // to one given surrounding DOM/CSSOM context this library never has access
+    // to), so treating them as resolvable named colors would mean fabricating an
+    // arbitrary RGB value with no way for a caller to tell it apart from a real
+    // one — see normalizeColor()'s `type: 'unknown'` fallback for these instead.
+    transparent: 'transparent',
+};

package/dist/esm/internal/transfer.d.ts

@@ -0,0 +1,2 @@
+export declare function srgbChanToLinear(v: number): number;
+export declare function linearChanToSrgb(v: number): number;

package/dist/esm/internal/transfer.js

@@ -0,0 +1,8 @@
+// sRGB transfer functions (operate on 0-1 values)
+export function srgbChanToLinear(v) {
+    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+}
+export function linearChanToSrgb(v) {
+    const t = v <= 0.0031308 ? 12.92 * v : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+    return Math.max(0, Math.min(1, t));
+}

package/dist/esm/manipulate.d.ts

@@ -0,0 +1,15 @@
+export declare function adjustHexBrightness(hex: string, offsetPercent: number): string;
+export declare function rotateHue(hex: string, degrees: number): string;
+export declare function lighten(color: string, amount: number): string;
+export declare function darken(color: string, amount: number): string;
+export declare function saturate(color: string, amount: number): string;
+export declare function desaturate(color: string, amount: number): string;
+export declare function setAlpha(color: string, alpha: number): string;
+export declare function getAlpha(color: string): number;
+export declare function invertColor(color: string): string;
+export declare function grayscale(color: string): string;
+export declare function mixColors(c1: string, c2: string, t: number, opts?: {
+    mode?: 'rgb' | 'hsl' | 'lab' | 'lch' | 'oklab' | 'oklch';
+    format?: 'hex' | 'rgb' | 'rgba' | 'hsl';
+    hueInterpolation?: 'shorter' | 'longer' | 'increasing' | 'decreasing';
+}): string;

package/dist/esm/manipulate.js

@@ -0,0 +1,210 @@
+// Adjusting and mixing colors.
+import { normalizeColor } from './parse.js';
+import { hexToHsl, hslToHex, hslToRgb, labToRgb, lchToRgb, normalizeHex, oklabToRgb, oklchToRgb, rgbToHex, rgbToHsl, rgbToLab, rgbToLch, rgbToOklab, rgbToOklch, rgbToRgbaString, } from './convert/spaces.js';
+export function adjustHexBrightness(hex, offsetPercent) {
+    const normalizedHex = normalizeHex(hex);
+    const p = Math.max(-100, Math.min(100, offsetPercent)) / 100;
+    const r = parseInt(normalizedHex.slice(1, 3), 16);
+    const g = parseInt(normalizedHex.slice(3, 5), 16);
+    const b = parseInt(normalizedHex.slice(5, 7), 16);
+    const adjustChannel = (channel) => {
+        if (p > 0)
+            return Math.min(255, Math.floor(channel + (255 - channel) * p));
+        else if (p < 0)
+            return Math.max(0, Math.floor(channel * (1 + p)));
+        return channel;
+    };
+    const newR = adjustChannel(r);
+    const newG = adjustChannel(g);
+    const newB = adjustChannel(b);
+    return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+}
+export function rotateHue(hex, degrees) {
+    const [h, s, l] = hexToHsl(hex);
+    const newH = (((h + degrees) % 360) + 360) % 360;
+    return hslToHex(newH, s, l);
+}
+export function lighten(color, amount) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const h = (_a = n.h) !== null && _a !== void 0 ? _a : 0;
+    const s = (_b = n.s) !== null && _b !== void 0 ? _b : 0;
+    const l = Math.min(100, ((_c = n.l) !== null && _c !== void 0 ? _c : 0) + amount);
+    return hslToHex(h, s, l);
+}
+export function darken(color, amount) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const h = (_a = n.h) !== null && _a !== void 0 ? _a : 0;
+    const s = (_b = n.s) !== null && _b !== void 0 ? _b : 0;
+    const l = Math.max(0, ((_c = n.l) !== null && _c !== void 0 ? _c : 0) - amount);
+    return hslToHex(h, s, l);
+}
+export function saturate(color, amount) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const h = (_a = n.h) !== null && _a !== void 0 ? _a : 0;
+    const s = Math.min(100, ((_b = n.s) !== null && _b !== void 0 ? _b : 0) + amount);
+    const l = (_c = n.l) !== null && _c !== void 0 ? _c : 0;
+    return hslToHex(h, s, l);
+}
+export function desaturate(color, amount) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const h = (_a = n.h) !== null && _a !== void 0 ? _a : 0;
+    const s = Math.max(0, ((_b = n.s) !== null && _b !== void 0 ? _b : 0) - amount);
+    const l = (_c = n.l) !== null && _c !== void 0 ? _c : 0;
+    return hslToHex(h, s, l);
+}
+export function setAlpha(color, alpha) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const r = (_a = n.r) !== null && _a !== void 0 ? _a : 0;
+    const g = (_b = n.g) !== null && _b !== void 0 ? _b : 0;
+    const b = (_c = n.b) !== null && _c !== void 0 ? _c : 0;
+    const a = Math.max(0, Math.min(1, alpha));
+    return `rgba(${r}, ${g}, ${b}, ${+a.toFixed(3)})`;
+}
+export function getAlpha(color) {
+    var _a;
+    const n = normalizeColor(color);
+    return (_a = n.a) !== null && _a !== void 0 ? _a : 1;
+}
+export function invertColor(color) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const r = 255 - ((_a = n.r) !== null && _a !== void 0 ? _a : 0);
+    const g = 255 - ((_b = n.g) !== null && _b !== void 0 ? _b : 0);
+    const b = 255 - ((_c = n.b) !== null && _c !== void 0 ? _c : 0);
+    return rgbToHex({ r, g, b });
+}
+export function grayscale(color) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const r = (_a = n.r) !== null && _a !== void 0 ? _a : 0;
+    const g = (_b = n.g) !== null && _b !== void 0 ? _b : 0;
+    const b = (_c = n.b) !== null && _c !== void 0 ? _c : 0;
+    // Perceptual luminance weights (ITU-R BT.709)
+    const gray = Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b);
+    return rgbToHex({ r: gray, g: gray, b: gray });
+}
+function _lerpHue(h1, h2, t, mode = 'shorter') {
+    let d = h2 - h1;
+    if (mode === 'shorter') {
+        if (d > 180)
+            d -= 360;
+        else if (d < -180)
+            d += 360;
+    }
+    else if (mode === 'longer') {
+        if (d > 0 && d < 180)
+            d -= 360;
+        else if (d < 0 && d > -180)
+            d += 360;
+    }
+    else if (mode === 'increasing') {
+        if (d < 0)
+            d += 360;
+    }
+    else if (mode === 'decreasing') {
+        if (d > 0)
+            d -= 360;
+    }
+    return h1 + d * t;
+}
+function _formatMixResult(r, g, b, a, out) {
+    if (out === 'hex')
+        return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+    if (out === 'rgba')
+        return rgbToRgbaString({ r: Math.round(r), g: Math.round(g), b: Math.round(b) }, a);
+    if (out === 'rgb')
+        return `rgb(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)})`;
+    if (out === 'hsl') {
+        const [hh, ss, ll] = rgbToHsl({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+        return `hsl(${hh}, ${ss}%, ${ll}%)`;
+    }
+    return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+}
+export function mixColors(c1, c2, t, opts) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35;
+    const o1 = normalizeColor(c1);
+    const o2 = normalizeColor(c2);
+    t = Math.max(0, Math.min(1, t));
+    const mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || 'rgb';
+    const out = (opts === null || opts === void 0 ? void 0 : opts.format) || 'hex';
+    const hueMode = (_a = opts === null || opts === void 0 ? void 0 : opts.hueInterpolation) !== null && _a !== void 0 ? _a : 'shorter';
+    let r = 0, g = 0, b = 0, a = 1;
+    if (mode === 'hsl') {
+        const h1 = (_b = o1.h) !== null && _b !== void 0 ? _b : rgbToHsl({ r: (_c = o1.r) !== null && _c !== void 0 ? _c : 0, g: (_d = o1.g) !== null && _d !== void 0 ? _d : 0, b: (_e = o1.b) !== null && _e !== void 0 ? _e : 0 })[0];
+        const s1 = (_f = o1.s) !== null && _f !== void 0 ? _f : 0;
+        const l1 = (_g = o1.l) !== null && _g !== void 0 ? _g : 0;
+        const h2 = (_h = o2.h) !== null && _h !== void 0 ? _h : rgbToHsl({ r: (_j = o2.r) !== null && _j !== void 0 ? _j : 0, g: (_k = o2.g) !== null && _k !== void 0 ? _k : 0, b: (_l = o2.b) !== null && _l !== void 0 ? _l : 0 })[0];
+        const s2 = (_m = o2.s) !== null && _m !== void 0 ? _m : 0;
+        const l2 = (_o = o2.l) !== null && _o !== void 0 ? _o : 0;
+        const ih = _lerpHue(h1, h2, t, hueMode);
+        const rgb = hslToRgb(ih, s1 + (s2 - s1) * t, l1 + (l2 - l1) * t);
+        r = rgb.r;
+        g = rgb.g;
+        b = rgb.b;
+        a = ((_p = o1.a) !== null && _p !== void 0 ? _p : 1) + (((_q = o2.a) !== null && _q !== void 0 ? _q : 1) - ((_r = o1.a) !== null && _r !== void 0 ? _r : 1)) * t;
+    }
+    else if (mode === 'lab') {
+        const lab1 = rgbToLab({ r: (_s = o1.r) !== null && _s !== void 0 ? _s : 0, g: (_t = o1.g) !== null && _t !== void 0 ? _t : 0, b: (_u = o1.b) !== null && _u !== void 0 ? _u : 0 });
+        const lab2 = rgbToLab({ r: (_v = o2.r) !== null && _v !== void 0 ? _v : 0, g: (_w = o2.g) !== null && _w !== void 0 ? _w : 0, b: (_x = o2.b) !== null && _x !== void 0 ? _x : 0 });
+        const mixed = labToRgb({
+            L: lab1.L + (lab2.L - lab1.L) * t,
+            a: lab1.a + (lab2.a - lab1.a) * t,
+            b: lab1.b + (lab2.b - lab1.b) * t,
+        });
+        r = mixed.r;
+        g = mixed.g;
+        b = mixed.b;
+        a = ((_y = o1.a) !== null && _y !== void 0 ? _y : 1) + (((_z = o2.a) !== null && _z !== void 0 ? _z : 1) - ((_0 = o1.a) !== null && _0 !== void 0 ? _0 : 1)) * t;
+    }
+    else if (mode === 'lch') {
+        const lch1 = rgbToLch({ r: (_1 = o1.r) !== null && _1 !== void 0 ? _1 : 0, g: (_2 = o1.g) !== null && _2 !== void 0 ? _2 : 0, b: (_3 = o1.b) !== null && _3 !== void 0 ? _3 : 0 });
+        const lch2 = rgbToLch({ r: (_4 = o2.r) !== null && _4 !== void 0 ? _4 : 0, g: (_5 = o2.g) !== null && _5 !== void 0 ? _5 : 0, b: (_6 = o2.b) !== null && _6 !== void 0 ? _6 : 0 });
+        const mixed = lchToRgb({
+            L: lch1.L + (lch2.L - lch1.L) * t,
+            C: lch1.C + (lch2.C - lch1.C) * t,
+            H: _lerpHue(lch1.H, lch2.H, t, hueMode),
+        });
+        r = mixed.r;
+        g = mixed.g;
+        b = mixed.b;
+        a = ((_7 = o1.a) !== null && _7 !== void 0 ? _7 : 1) + (((_8 = o2.a) !== null && _8 !== void 0 ? _8 : 1) - ((_9 = o1.a) !== null && _9 !== void 0 ? _9 : 1)) * t;
+    }
+    else if (mode === 'oklab') {
+        const ok1 = rgbToOklab({ r: (_10 = o1.r) !== null && _10 !== void 0 ? _10 : 0, g: (_11 = o1.g) !== null && _11 !== void 0 ? _11 : 0, b: (_12 = o1.b) !== null && _12 !== void 0 ? _12 : 0 });
+        const ok2 = rgbToOklab({ r: (_13 = o2.r) !== null && _13 !== void 0 ? _13 : 0, g: (_14 = o2.g) !== null && _14 !== void 0 ? _14 : 0, b: (_15 = o2.b) !== null && _15 !== void 0 ? _15 : 0 });
+        const mixed = oklabToRgb({
+            L: ok1.L + (ok2.L - ok1.L) * t,
+            a: ok1.a + (ok2.a - ok1.a) * t,
+            b: ok1.b + (ok2.b - ok1.b) * t,
+        });
+        r = mixed.r;
+        g = mixed.g;
+        b = mixed.b;
+        a = ((_16 = o1.a) !== null && _16 !== void 0 ? _16 : 1) + (((_17 = o2.a) !== null && _17 !== void 0 ? _17 : 1) - ((_18 = o1.a) !== null && _18 !== void 0 ? _18 : 1)) * t;
+    }
+    else if (mode === 'oklch') {
+        const ok1 = rgbToOklch({ r: (_19 = o1.r) !== null && _19 !== void 0 ? _19 : 0, g: (_20 = o1.g) !== null && _20 !== void 0 ? _20 : 0, b: (_21 = o1.b) !== null && _21 !== void 0 ? _21 : 0 });
+        const ok2 = rgbToOklch({ r: (_22 = o2.r) !== null && _22 !== void 0 ? _22 : 0, g: (_23 = o2.g) !== null && _23 !== void 0 ? _23 : 0, b: (_24 = o2.b) !== null && _24 !== void 0 ? _24 : 0 });
+        const mixed = oklchToRgb({
+            L: ok1.L + (ok2.L - ok1.L) * t,
+            C: ok1.C + (ok2.C - ok1.C) * t,
+            H: _lerpHue(ok1.H, ok2.H, t, hueMode),
+        });
+        r = mixed.r;
+        g = mixed.g;
+        b = mixed.b;
+        a = ((_25 = o1.a) !== null && _25 !== void 0 ? _25 : 1) + (((_26 = o2.a) !== null && _26 !== void 0 ? _26 : 1) - ((_27 = o1.a) !== null && _27 !== void 0 ? _27 : 1)) * t;
+    }
+    else {
+        r = ((_28 = o1.r) !== null && _28 !== void 0 ? _28 : 0) * (1 - t) + ((_29 = o2.r) !== null && _29 !== void 0 ? _29 : 0) * t;
+        g = ((_30 = o1.g) !== null && _30 !== void 0 ? _30 : 0) * (1 - t) + ((_31 = o2.g) !== null && _31 !== void 0 ? _31 : 0) * t;
+        b = ((_32 = o1.b) !== null && _32 !== void 0 ? _32 : 0) * (1 - t) + ((_33 = o2.b) !== null && _33 !== void 0 ? _33 : 0) * t;
+        a = ((_34 = o1.a) !== null && _34 !== void 0 ? _34 : 1) * (1 - t) + ((_35 = o2.a) !== null && _35 !== void 0 ? _35 : 1) * t;
+    }
+    return _formatMixResult(r, g, b, a, out);
+}

package/dist/esm/package.json

@@ -1 +1,3 @@
-{"type":"module"}
+{
+  "type": "module"
+}

package/dist/esm/palette.d.ts

@@ -0,0 +1,40 @@
+export declare function complement(color: string): string;
+export declare function triadic(color: string): [string, string, string];
+export declare function analogous(color: string, angle?: number): [string, string, string];
+export declare function splitComplementary(color: string): [string, string, string];
+export declare function tetradic(color: string): [string, string, string, string];
+export declare function colorShades(color: string, steps?: number): string[];
+export declare function monochromatic(color: string, steps?: number): string[];
+export declare function randomColor(options?: {
+    hRange?: [number, number];
+    sRange?: [number, number];
+    lRange?: [number, number];
+}): string;
+export declare function interpolateColors(color1: string, color2: string, steps: number, options?: {
+    space?: 'rgb' | 'hsl' | 'lab' | 'lch' | 'oklab' | 'oklch';
+    format?: 'hex' | 'rgb' | 'rgba' | 'hsl';
+    hueInterpolation?: 'shorter' | 'longer' | 'increasing' | 'decreasing';
+}): string[];
+export declare function createColorScale(anchors: string[] | Array<{
+    color: string;
+    position?: number;
+}>, steps: number, options?: {
+    space?: 'rgb' | 'hsl' | 'oklab' | 'oklch';
+    format?: 'hex' | 'rgb' | 'hsl';
+}): string[];
+export declare function midpointColor(color1: string, color2: string, options?: {
+    space?: 'lab' | 'lch' | 'oklab' | 'oklch';
+}): string;
+export declare function tints(color: string, steps?: number): string[];
+export declare function shades(color: string, steps?: number): string[];
+export declare function tones(color: string, steps?: number, gray?: string): string[];
+export declare function generateGradientColors(start: string, end: string, steps: number, options?: {
+    mode?: 'rgb' | 'hsl' | 'oklab' | 'oklch';
+    format?: 'hex' | 'rgb' | 'hsl';
+}): Generator<string>;
+export declare function generateTints(color: string, steps: number, options?: {
+    format?: 'hex' | 'rgb' | 'hsl';
+}): Generator<string>;
+export declare function generateShades(color: string, steps: number, options?: {
+    format?: 'hex' | 'rgb' | 'hsl';
+}): Generator<string>;

package/dist/esm/palette.js

@@ -0,0 +1,145 @@
+// Harmonies, scales, tints/shades and color generators.
+import { normalizeColor } from './parse.js';
+import { hslToHex } from './convert/spaces.js';
+import { mixColors, rotateHue } from './manipulate.js';
+export function complement(color) {
+    var _a;
+    return rotateHue((_a = normalizeColor(color).hex) !== null && _a !== void 0 ? _a : '#000000', 180);
+}
+export function triadic(color) {
+    var _a;
+    const hex = (_a = normalizeColor(color).hex) !== null && _a !== void 0 ? _a : '#000000';
+    return [hex, rotateHue(hex, 120), rotateHue(hex, 240)];
+}
+export function analogous(color, angle = 30) {
+    var _a;
+    const hex = (_a = normalizeColor(color).hex) !== null && _a !== void 0 ? _a : '#000000';
+    return [rotateHue(hex, -angle), hex, rotateHue(hex, angle)];
+}
+export function splitComplementary(color) {
+    var _a;
+    const hex = (_a = normalizeColor(color).hex) !== null && _a !== void 0 ? _a : '#000000';
+    return [hex, rotateHue(hex, 150), rotateHue(hex, 210)];
+}
+export function tetradic(color) {
+    var _a;
+    const hex = (_a = normalizeColor(color).hex) !== null && _a !== void 0 ? _a : '#000000';
+    return [hex, rotateHue(hex, 90), rotateHue(hex, 180), rotateHue(hex, 270)];
+}
+export function colorShades(color, steps = 9) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const h = (_a = n.h) !== null && _a !== void 0 ? _a : 0;
+    const s = (_b = n.s) !== null && _b !== void 0 ? _b : 0;
+    // steps - 1 === 0 below would otherwise divide by zero (NaN lightness, then
+    // a literal "#NaNNaNNaN" hex string) — a single shade is just the color's
+    // own lightness, same idea as interpolateColors() returning the midpoint
+    // for a 2-color, 1-step request.
+    if (steps <= 1)
+        return steps === 1 ? [hslToHex(h, s, (_c = n.l) !== null && _c !== void 0 ? _c : 50)] : [];
+    const result = [];
+    for (let i = 0; i < steps; i++) {
+        const l = Math.round(100 - (i / (steps - 1)) * 100);
+        result.push(hslToHex(h, s, l));
+    }
+    return result;
+}
+export function monochromatic(color, steps = 5) {
+    var _a, _b, _c;
+    const n = normalizeColor(color);
+    const h = (_a = n.h) !== null && _a !== void 0 ? _a : 0;
+    const l = (_b = n.l) !== null && _b !== void 0 ? _b : 50;
+    // Same steps === 1 divide-by-zero guard as colorShades() above.
+    if (steps <= 1)
+        return steps === 1 ? [hslToHex(h, (_c = n.s) !== null && _c !== void 0 ? _c : 0, l)] : [];
+    const result = [];
+    for (let i = 0; i < steps; i++) {
+        const s = Math.round((i / (steps - 1)) * 100);
+        result.push(hslToHex(h, s, l));
+    }
+    return result;
+}
+export function randomColor(options) {
+    var _a, _b, _c;
+    const [hMin, hMax] = (_a = options === null || options === void 0 ? void 0 : options.hRange) !== null && _a !== void 0 ? _a : [0, 360];
+    const [sMin, sMax] = (_b = options === null || options === void 0 ? void 0 : options.sRange) !== null && _b !== void 0 ? _b : [40, 90];
+    const [lMin, lMax] = (_c = options === null || options === void 0 ? void 0 : options.lRange) !== null && _c !== void 0 ? _c : [30, 70];
+    const h = Math.floor(Math.random() * (hMax - hMin)) + hMin;
+    const s = Math.floor(Math.random() * (sMax - sMin)) + sMin;
+    const l = Math.floor(Math.random() * (lMax - lMin)) + lMin;
+    return hslToHex(h, s, l);
+}
+// ─── Interpolation ─────────────────────────────────────────────────
+export function interpolateColors(color1, color2, steps, options) {
+    if (steps < 2)
+        return steps === 1 ? [mixColors(color1, color2, 0.5, options)] : [];
+    const result = [];
+    for (let i = 0; i < steps; i++) {
+        result.push(mixColors(color1, color2, i / (steps - 1), options));
+    }
+    return result;
+}
+export function createColorScale(anchors, steps, options) {
+    const normalized = anchors.map((a, i, arr) => {
+        var _a;
+        return ({
+            color: typeof a === 'string' ? a : a.color,
+            position: typeof a === 'string'
+                ? i / Math.max(arr.length - 1, 1)
+                : ((_a = a.position) !== null && _a !== void 0 ? _a : i / Math.max(arr.length - 1, 1)),
+        });
+    });
+    normalized.sort((a, b) => a.position - b.position);
+    const result = [];
+    for (let i = 0; i < steps; i++) {
+        const t = steps === 1 ? 0 : i / (steps - 1);
+        let lo = normalized[0], hi = normalized[normalized.length - 1];
+        for (let j = 0; j < normalized.length - 1; j++) {
+            if (t >= normalized[j].position && t <= normalized[j + 1].position) {
+                lo = normalized[j];
+                hi = normalized[j + 1];
+                break;
+            }
+        }
+        const span = hi.position - lo.position;
+        const localT = span === 0 ? 0 : (t - lo.position) / span;
+        result.push(mixColors(lo.color, hi.color, localT, options));
+    }
+    return result;
+}
+export function midpointColor(color1, color2, options) {
+    var _a;
+    return mixColors(color1, color2, 0.5, { mode: (_a = options === null || options === void 0 ? void 0 : options.space) !== null && _a !== void 0 ? _a : 'oklab' });
+}
+// ─── Tints / Shades / Tones ───────────────────────────────────────
+export function tints(color, steps = 5) {
+    return interpolateColors(color, '#ffffff', steps, { space: 'oklab' });
+}
+export function shades(color, steps = 5) {
+    return interpolateColors(color, '#000000', steps, { space: 'oklab' });
+}
+export function tones(color, steps = 5, gray = '#808080') {
+    return interpolateColors(color, gray, steps, { space: 'oklab' });
+}
+// ─── Generator functions ────────────────────────────────────────
+export function* generateGradientColors(start, end, steps, options) {
+    for (let i = 0; i < steps; i++) {
+        yield mixColors(start, end, steps === 1 ? 0 : i / (steps - 1), options);
+    }
+}
+export function* generateTints(color, steps, options) {
+    for (let i = 0; i < steps; i++) {
+        yield mixColors(color, '#ffffff', steps === 1 ? 0 : i / (steps - 1), {
+            mode: 'oklab',
+            ...options,
+        });
+    }
+}
+export function* generateShades(color, steps, options) {
+    for (let i = 0; i < steps; i++) {
+        yield mixColors(color, '#000000', steps === 1 ? 0 : i / (steps - 1), {
+            mode: 'oklab',
+            ...options,
+        });
+    }
+}