@design-edito/tools 0.4.4 → 0.4.6

package/agnostic/colors/grayscale/index.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { grayscale } from './index.js';
+import { toRgb } from '../convert/index.js';
+describe('grayscale', () => {
+    it('converts color to grayscale using lab method by default', () => {
+        const result = grayscale({ r: 255, g: 128, b: 64 });
+        const rgb = toRgb(result);
+        expect(rgb.r).toBe(rgb.g);
+        expect(rgb.g).toBe(rgb.b);
+    });
+    it('preserves color format', () => {
+        const hslColor = { h: 180, s: 50, l: 75 };
+        const result = grayscale(hslColor);
+        expect(result).toHaveProperty('h');
+        expect(result).toHaveProperty('s');
+        expect(result).toHaveProperty('l');
+    });
+    it('converts using rgb-avg method', () => {
+        const result = grayscale({ r: 255, g: 128, b: 64 }, 'rgb-avg');
+        const rgb = toRgb(result);
+        expect(rgb.r).toBe(rgb.g);
+        expect(rgb.g).toBe(rgb.b);
+    });
+    it('converts using hsl method', () => {
+        const result = grayscale({ h: 180, s: 50, l: 75 }, 'hsl');
+        expect(result).toMatchObject({ s: 0 });
+    });
+    it('converts using lch method', () => {
+        const result = grayscale({ r: 255, g: 128, b: 64 }, 'lch');
+        const rgb = toRgb(result);
+        expect(rgb.r).toBe(rgb.g);
+        expect(rgb.g).toBe(rgb.b);
+    });
+});

package/agnostic/colors/invert/index.js

@@ -1,51 +1,40 @@
-import {
-  viaLab,
-  viaLch,
-  viaRgb
-} from "../../../chunks/chunk-CVMYA5XK.js";
-import "../../../chunks/chunk-OBSTP7YR.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import {
-  absoluteModulo
-} from "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/agnostic/colors/invert/index.ts
+import { viaRgb, viaLab, viaLch } from '../convert/index.js';
+import { absoluteModulo } from '../../numbers/absolute-modulo/index.js';
 function invertRgb(color) {
-  return viaRgb(color, (rgb) => ({
-    ...rgb,
-    r: 255 - rgb.r,
-    g: 255 - rgb.g,
-    b: 255 - rgb.b
-  }));
+    return viaRgb(color, rgb => ({
+        ...rgb,
+        r: 255 - rgb.r,
+        g: 255 - rgb.g,
+        b: 255 - rgb.b
+    }));
 }
 function invertLab(color) {
-  return viaLab(color, (lab) => ({
-    ...lab,
-    l: 100 - lab.l,
-    a: -1 * lab.a,
-    b: -1 * lab.b
-  }));
+    return viaLab(color, lab => ({
+        ...lab,
+        l: 100 - lab.l,
+        a: -1 * lab.a,
+        b: -1 * lab.b
+    }));
 }
 function invertLch(color) {
-  return viaLch(color, (lch) => ({
-    ...lch,
-    l: 100 - lch.l,
-    h: absoluteModulo(lch.h + 180, 360)
-  }));
+    return viaLch(color, lch => ({
+        ...lch,
+        l: 100 - lch.l,
+        h: absoluteModulo(lch.h + 180, 360)
+    }));
 }
-function invert(color, method = "lch") {
-  switch (method) {
-    case "rgb":
-      return invertRgb(color);
-    case "lab":
-      return invertLab(color);
-    case "lch":
-      return invertLch(color);
-  }
+/**
+ * Inverts a color using the specified method.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to invert.
+ * @param {InvertMethod} [method='lch'] - The inversion method to use.
+ * @returns {TransformedColor<C>} The inverted color in the original format.
+ */
+export function invert(color, method = 'lch') {
+    switch (method) {
+        case 'rgb': return invertRgb(color);
+        case 'lab': return invertLab(color);
+        case 'lch': return invertLch(color);
+    }
 }
-export {
-  invert
-};

package/agnostic/colors/invert/index.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { invert } from './index.js';
+import { toRgb } from '../convert/index.js';
+describe('invert', () => {
+    it('inverts color using lch method by default', () => {
+        const result = invert({ r: 255, g: 0, b: 0 });
+        const rgb = toRgb(result);
+        expect(rgb.r).not.toBe(255);
+    });
+    it('preserves color format', () => {
+        const hslColor = { h: 180, s: 50, l: 75 };
+        const result = invert(hslColor);
+        expect(result).toHaveProperty('h');
+        expect(result).toHaveProperty('s');
+        expect(result).toHaveProperty('l');
+    });
+    it('inverts using rgb method', () => {
+        const result = invert({ r: 255, g: 128, b: 64 }, 'rgb');
+        const rgb = toRgb(result);
+        expect(rgb.r).toBe(0);
+        expect(rgb.g).toBe(127);
+        expect(rgb.b).toBe(191);
+    });
+    it('inverts using lab method', () => {
+        const result = invert({ r: 255, g: 0, b: 0 }, 'lab');
+        const rgb = toRgb(result);
+        expect(rgb).toHaveProperty('r');
+        expect(rgb).toHaveProperty('g');
+        expect(rgb).toHaveProperty('b');
+    });
+});

package/agnostic/colors/lerp/index.js

@@ -1,103 +1,89 @@
-import {
-  toHsb,
-  toHsl,
-  toLab,
-  toLch,
-  toRgb,
-  toXyz,
-  viaHsb,
-  viaHsl,
-  viaLab,
-  viaLch,
-  viaRgb,
-  viaXyz
-} from "../../../chunks/chunk-CVMYA5XK.js";
-import "../../../chunks/chunk-OBSTP7YR.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/agnostic/colors/lerp/index.ts
+import { viaRgb, viaLab, viaLch, viaHsl, viaHsb, viaXyz, toRgb, toLab, toLch, toHsl, toHsb, toXyz } from '../convert/index.js';
 function lerpRgb(rgb1, rgb2, amount) {
-  const r = rgb1.r + (rgb2.r - rgb1.r) * amount;
-  const g = rgb1.g + (rgb2.g - rgb1.g) * amount;
-  const b = rgb1.b + (rgb2.b - rgb1.b) * amount;
-  const a = (rgb1.a ?? 1) + ((rgb2.a ?? 1) - (rgb1.a ?? 1)) * amount;
-  return { r, g, b, a };
+    const r = rgb1.r + (rgb2.r - rgb1.r) * amount;
+    const g = rgb1.g + (rgb2.g - rgb1.g) * amount;
+    const b = rgb1.b + (rgb2.b - rgb1.b) * amount;
+    const a = (rgb1.a ?? 1) + ((rgb2.a ?? 1) - (rgb1.a ?? 1)) * amount;
+    return { r, g, b, a };
 }
 function lerpLab(lab1, lab2, amount) {
-  const l = lab1.l + (lab2.l - lab1.l) * amount;
-  const a = lab1.a + (lab2.a - lab1.a) * amount;
-  const b = lab1.b + (lab2.b - lab1.b) * amount;
-  const al = (lab1.al ?? 1) + ((lab2.al ?? 1) - (lab1.al ?? 1)) * amount;
-  return { l, a, b, al };
+    const l = lab1.l + (lab2.l - lab1.l) * amount;
+    const a = lab1.a + (lab2.a - lab1.a) * amount;
+    const b = lab1.b + (lab2.b - lab1.b) * amount;
+    const al = (lab1.al ?? 1) + ((lab2.al ?? 1) - (lab1.al ?? 1)) * amount;
+    return { l, a, b, al };
 }
 function lerpLch(lch1, lch2, amount) {
-  const l = lch1.l + (lch2.l - lch1.l) * amount;
-  const c = lch1.c + (lch2.c - lch1.c) * amount;
-  let hDiff = lch2.h - lch1.h;
-  if (hDiff > 180) hDiff -= 360;
-  if (hDiff < -180) hDiff += 360;
-  const h = (lch1.h + hDiff * amount + 360) % 360;
-  const a = (lch1.a ?? 1) + ((lch2.a ?? 1) - (lch1.a ?? 1)) * amount;
-  return { l, c, h, a };
+    const l = lch1.l + (lch2.l - lch1.l) * amount;
+    const c = lch1.c + (lch2.c - lch1.c) * amount;
+    let hDiff = lch2.h - lch1.h;
+    if (hDiff > 180)
+        hDiff -= 360;
+    if (hDiff < -180)
+        hDiff += 360;
+    const h = (lch1.h + hDiff * amount + 360) % 360;
+    const a = (lch1.a ?? 1) + ((lch2.a ?? 1) - (lch1.a ?? 1)) * amount;
+    return { l, c, h, a };
 }
 function lerpHsl(hsl1, hsl2, amount) {
-  const l = hsl1.l + (hsl2.l - hsl1.l) * amount;
-  const s = hsl1.s + (hsl2.s - hsl1.s) * amount;
-  let hDiff = hsl2.h - hsl1.h;
-  if (hDiff > 180) hDiff -= 360;
-  if (hDiff < -180) hDiff += 360;
-  const h = (hsl1.h + hDiff * amount + 360) % 360;
-  const a = (hsl1.a ?? 1) + ((hsl2.a ?? 1) - (hsl1.a ?? 1)) * amount;
-  return { h, s, l, a };
+    const l = hsl1.l + (hsl2.l - hsl1.l) * amount;
+    const s = hsl1.s + (hsl2.s - hsl1.s) * amount;
+    let hDiff = hsl2.h - hsl1.h;
+    if (hDiff > 180)
+        hDiff -= 360;
+    if (hDiff < -180)
+        hDiff += 360;
+    const h = (hsl1.h + hDiff * amount + 360) % 360;
+    const a = (hsl1.a ?? 1) + ((hsl2.a ?? 1) - (hsl1.a ?? 1)) * amount;
+    return { h, s, l, a };
 }
 function lerpHsb(hsb1, hsb2, amount) {
-  const b = hsb1.b + (hsb2.b - hsb1.b) * amount;
-  const s = hsb1.s + (hsb2.s - hsb1.s) * amount;
-  let hDiff = hsb2.h - hsb1.h;
-  if (hDiff > 180) hDiff -= 360;
-  if (hDiff < -180) hDiff += 360;
-  const h = (hsb1.h + hDiff * amount + 360) % 360;
-  const a = (hsb1.a ?? 1) + ((hsb2.a ?? 1) - (hsb1.a ?? 1)) * amount;
-  return { h, s, b, a };
+    const b = hsb1.b + (hsb2.b - hsb1.b) * amount;
+    const s = hsb1.s + (hsb2.s - hsb1.s) * amount;
+    let hDiff = hsb2.h - hsb1.h;
+    if (hDiff > 180)
+        hDiff -= 360;
+    if (hDiff < -180)
+        hDiff += 360;
+    const h = (hsb1.h + hDiff * amount + 360) % 360;
+    const a = (hsb1.a ?? 1) + ((hsb2.a ?? 1) - (hsb1.a ?? 1)) * amount;
+    return { h, s, b, a };
 }
 function lerpLinearRgb(rgb1, rgb2, amount) {
-  const linearChannel = (v) => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-  const delinearize = (v) => v <= 31308e-7 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
-  const r = delinearize(linearChannel(rgb1.r) + (linearChannel(rgb2.r) - linearChannel(rgb1.r)) * amount);
-  const g = delinearize(linearChannel(rgb1.g) + (linearChannel(rgb2.g) - linearChannel(rgb1.g)) * amount);
-  const b = delinearize(linearChannel(rgb1.b) + (linearChannel(rgb2.b) - linearChannel(rgb1.b)) * amount);
-  const a = (rgb1.a ?? 1) + ((rgb2.a ?? 1) - (rgb1.a ?? 1)) * amount;
-  return { r, g, b, a };
+    const linearChannel = (v) => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    const delinearize = (v) => v <= 0.0031308 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+    const r = delinearize(linearChannel(rgb1.r) + (linearChannel(rgb2.r) - linearChannel(rgb1.r)) * amount);
+    const g = delinearize(linearChannel(rgb1.g) + (linearChannel(rgb2.g) - linearChannel(rgb1.g)) * amount);
+    const b = delinearize(linearChannel(rgb1.b) + (linearChannel(rgb2.b) - linearChannel(rgb1.b)) * amount);
+    const a = (rgb1.a ?? 1) + ((rgb2.a ?? 1) - (rgb1.a ?? 1)) * amount;
+    return { r, g, b, a };
 }
 function lerpXyz(xyz1, xyz2, amount) {
-  const x = xyz1.x + (xyz2.x - xyz1.x) * amount;
-  const y = xyz1.y + (xyz2.y - xyz1.y) * amount;
-  const z = xyz1.z + (xyz2.z - xyz1.z) * amount;
-  const a = (xyz1.a ?? 1) + ((xyz2.a ?? 1) - (xyz1.a ?? 1)) * amount;
-  return { x, y, z, a };
+    const x = xyz1.x + (xyz2.x - xyz1.x) * amount;
+    const y = xyz1.y + (xyz2.y - xyz1.y) * amount;
+    const z = xyz1.z + (xyz2.z - xyz1.z) * amount;
+    const a = (xyz1.a ?? 1) + ((xyz2.a ?? 1) - (xyz1.a ?? 1)) * amount;
+    return { x, y, z, a };
 }
-function lerp(c1, c2, amount, method = "rgb") {
-  switch (method) {
-    case "rgb":
-      return viaRgb(c1, (rgb1) => lerpRgb(rgb1, toRgb(c2), amount));
-    case "lab":
-      return viaLab(c1, (lab1) => lerpLab(lab1, toLab(c2), amount));
-    case "lch":
-      return viaLch(c1, (lch1) => lerpLch(lch1, toLch(c2), amount));
-    case "hsl":
-      return viaHsl(c1, (hsl1) => lerpHsl(hsl1, toHsl(c2), amount));
-    case "hsb":
-      return viaHsb(c1, (hsb1) => lerpHsb(hsb1, toHsb(c2), amount));
-    case "rgb-linear":
-      return viaRgb(c1, (rgb1) => lerpLinearRgb(rgb1, toRgb(c2), amount));
-    case "xyz":
-      return viaXyz(c1, (xyz1) => lerpXyz(xyz1, toXyz(c2), amount));
-  }
+/**
+ * Linearly interpolates between two colors using the specified method.
+ *
+ * @template C1 - The first color type.
+ * @template C2 - The second color type.
+ * @param {C1} c1 - The starting color.
+ * @param {C2} c2 - The ending color.
+ * @param {number} amount - The interpolation amount (0-1), where 0 returns c1 and 1 returns c2.
+ * @param {LerpMethod} [method='rgb'] - The interpolation method to use.
+ * @returns {TransformedColor<C1>} The interpolated color in the format of c1.
+ */
+export function lerp(c1, c2, amount, method = 'rgb') {
+    switch (method) {
+        case 'rgb': return viaRgb(c1, rgb1 => lerpRgb(rgb1, toRgb(c2), amount));
+        case 'lab': return viaLab(c1, lab1 => lerpLab(lab1, toLab(c2), amount));
+        case 'lch': return viaLch(c1, lch1 => lerpLch(lch1, toLch(c2), amount));
+        case 'hsl': return viaHsl(c1, hsl1 => lerpHsl(hsl1, toHsl(c2), amount));
+        case 'hsb': return viaHsb(c1, hsb1 => lerpHsb(hsb1, toHsb(c2), amount));
+        case 'rgb-linear': return viaRgb(c1, rgb1 => lerpLinearRgb(rgb1, toRgb(c2), amount));
+        case 'xyz': return viaXyz(c1, xyz1 => lerpXyz(xyz1, toXyz(c2), amount));
+    }
 }
-export {
-  lerp
-};

package/agnostic/colors/lerp/index.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { lerp } from './index.js';
+import { toRgb } from '../convert/index.js';
+describe('lerp', () => {
+    it('returns first color when amount is 0', () => {
+        const c1 = { r: 255, g: 0, b: 0 };
+        const c2 = { r: 0, g: 255, b: 0 };
+        const result = lerp(c1, c2, 0);
+        const rgb = toRgb(result);
+        expect(rgb.r).toBe(255);
+        expect(rgb.g).toBe(0);
+        expect(rgb.b).toBe(0);
+    });
+    it('returns second color when amount is 1', () => {
+        const c1 = { r: 255, g: 0, b: 0 };
+        const c2 = { r: 0, g: 255, b: 0 };
+        const result = lerp(c1, c2, 1);
+        const rgb = toRgb(result);
+        expect(rgb.r).toBe(0);
+        expect(rgb.g).toBe(255);
+        expect(rgb.b).toBe(0);
+    });
+    it('interpolates between colors', () => {
+        const c1 = { r: 0, g: 0, b: 0 };
+        const c2 = { r: 255, g: 255, b: 255 };
+        const result = lerp(c1, c2, 0.5);
+        const rgb = toRgb(result);
+        expect(rgb.r).toBeGreaterThan(0);
+        expect(rgb.r).toBeLessThan(255);
+    });
+    it('preserves first color format', () => {
+        const c1 = { h: 0, s: 100, l: 50 };
+        const c2 = { r: 0, g: 255, b: 0 };
+        const result = lerp(c1, c2, 0.5);
+        expect(result).toHaveProperty('h');
+        expect(result).toHaveProperty('s');
+        expect(result).toHaveProperty('l');
+    });
+    it('uses rgb method by default', () => {
+        const c1 = { r: 0, g: 0, b: 0 };
+        const c2 = { r: 255, g: 255, b: 255 };
+        const result1 = lerp(c1, c2, 0.5);
+        const result2 = lerp(c1, c2, 0.5, 'rgb');
+        expect(toRgb(result1)).toEqual(toRgb(result2));
+    });
+    it('interpolates using lab method', () => {
+        const c1 = { r: 255, g: 0, b: 0 };
+        const c2 = { r: 0, g: 255, b: 0 };
+        const result = lerp(c1, c2, 0.5, 'lab');
+        const rgb = toRgb(result);
+        expect(rgb).toHaveProperty('r');
+        expect(rgb).toHaveProperty('g');
+        expect(rgb).toHaveProperty('b');
+    });
+});

package/agnostic/colors/luminance/index.js

@@ -1,13 +1,19 @@
-import {
-  luminance
-} from "../../../chunks/chunk-E2ZY3SEW.js";
-import "../../../chunks/chunk-CVMYA5XK.js";
-import "../../../chunks/chunk-OBSTP7YR.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  luminance
-};
+import { linearizeToSRgb, toLab, toRgb, toXyz } from '../convert/index.js';
+function luminanceRgb(rgb) {
+    const { linearR, linearG, linearB } = linearizeToSRgb(rgb);
+    return (0.2126 * linearR + 0.7152 * linearG + 0.0722 * linearB);
+}
+/**
+ * Calculates the relative luminance of a color using the specified method.
+ *
+ * @param {Color} color - The color to analyze.
+ * @param {LuminanceMethod} [method='lab'] - The calculation method to use.
+ * @returns {number} The relative luminance value (0-1).
+ */
+export function luminance(color, method = 'lab') {
+    switch (method) {
+        case 'rgb': return luminanceRgb(toRgb(color));
+        case 'xyz': return toXyz(color).y / 100;
+        case 'lab': return toLab(color).l / 100;
+    }
+}

package/agnostic/colors/luminance/index.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { luminance } from './index.js';
+describe('luminance', () => {
+    it('returns high luminance for white', () => {
+        const result = luminance({ r: 255, g: 255, b: 255 });
+        expect(result).toBeGreaterThan(0.9);
+    });
+    it('returns low luminance for black', () => {
+        const result = luminance({ r: 0, g: 0, b: 0 });
+        expect(result).toBeLessThan(0.1);
+    });
+    it('returns value between 0 and 1', () => {
+        const result = luminance({ r: 128, g: 128, b: 128 });
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(result).toBeLessThanOrEqual(1);
+    });
+    it('uses lab method by default', () => {
+        const result1 = luminance({ r: 128, g: 128, b: 128 });
+        const result2 = luminance({ r: 128, g: 128, b: 128 }, 'lab');
+        expect(result1).toBe(result2);
+    });
+    it('calculates using rgb method', () => {
+        const result = luminance({ r: 255, g: 255, b: 255 }, 'rgb');
+        expect(result).toBeGreaterThan(0.9);
+    });
+    it('calculates using xyz method', () => {
+        const result = luminance({ r: 255, g: 255, b: 255 }, 'xyz');
+        expect(result).toBeGreaterThan(0.9);
+    });
+});

package/agnostic/colors/palette/index.js

@@ -1,112 +1,105 @@
-import {
-  rotate
-} from "../../../chunks/chunk-YY3TSU22.js";
-import "../../../chunks/chunk-WGRQXVBK.js";
-import "../../../chunks/chunk-CVMYA5XK.js";
-import "../../../chunks/chunk-OBSTP7YR.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/agnostic/colors/palette/index.ts
+import { rotate } from '../rotate/index.js';
+/* * * * * * * * * * * * * * * * * *
+ * Complementary
+ * * * * * * * * * * * * * * * * * */
 function complementaryHsl(color) {
-  return rotate(color, 180, "hsl");
+    return rotate(color, 180, 'hsl');
 }
 function complementaryLab(color) {
-  return rotate(color, 180, "lab");
+    return rotate(color, 180, 'lab');
 }
 function complementaryLch(color) {
-  return rotate(color, 180, "lch");
+    return rotate(color, 180, 'lch');
 }
+/* * * * * * * * * * * * * * * * * *
+ * Split Complementary
+ * * * * * * * * * * * * * * * * * */
 function splitComplementaryHsl(color) {
-  return [
-    rotate(color, 150, "hsl"),
-    rotate(color, 210, "hsl")
-  ];
+    return [
+        rotate(color, 150, 'hsl'),
+        rotate(color, 210, 'hsl')
+    ];
 }
 function splitComplementaryLab(color) {
-  return [
-    rotate(color, 150, "lab"),
-    rotate(color, 210, "lab")
-  ];
+    return [
+        rotate(color, 150, 'lab'),
+        rotate(color, 210, 'lab')
+    ];
 }
 function splitComplementaryLch(color) {
-  return [
-    rotate(color, 150, "lch"),
-    rotate(color, 210, "lch")
-  ];
+    return [
+        rotate(color, 150, 'lch'),
+        rotate(color, 210, 'lch')
+    ];
 }
+/* * * * * * * * * * * * * * * * * *
+ * Triadic
+ * * * * * * * * * * * * * * * * * */
 function triadicHsl(color) {
-  return [
-    rotate(color, 120, "hsl"),
-    rotate(color, 240, "hsl")
-  ];
+    return [
+        rotate(color, 120, 'hsl'),
+        rotate(color, 240, 'hsl')
+    ];
 }
 function triadicLab(color) {
-  return [
-    rotate(color, 120, "lab"),
-    rotate(color, 240, "lab")
-  ];
+    return [
+        rotate(color, 120, 'lab'),
+        rotate(color, 240, 'lab')
+    ];
 }
 function triadicLch(color) {
-  return [
-    rotate(color, 120, "lch"),
-    rotate(color, 240, "lch")
-  ];
+    return [
+        rotate(color, 120, 'lch'),
+        rotate(color, 240, 'lch')
+    ];
 }
+/* * * * * * * * * * * * * * * * * *
+ * Tetradic
+ * * * * * * * * * * * * * * * * * */
 function tetradicHsl(color) {
-  return [
-    rotate(color, 90, "hsl"),
-    rotate(color, 180, "hsl"),
-    rotate(color, 270, "hsl")
-  ];
+    return [
+        rotate(color, 90, 'hsl'),
+        rotate(color, 180, 'hsl'),
+        rotate(color, 270, 'hsl')
+    ];
 }
 function tetradicLab(color) {
-  return [
-    rotate(color, 90, "lab"),
-    rotate(color, 180, "lab"),
-    rotate(color, 270, "lab")
-  ];
+    return [
+        rotate(color, 90, 'lab'),
+        rotate(color, 180, 'lab'),
+        rotate(color, 270, 'lab')
+    ];
 }
 function tetradicLch(color) {
-  return [
-    rotate(color, 90, "lch"),
-    rotate(color, 180, "lch"),
-    rotate(color, 270, "lch")
-  ];
+    return [
+        rotate(color, 90, 'lch'),
+        rotate(color, 180, 'lch'),
+        rotate(color, 270, 'lch')
+    ];
 }
-function palette(color, type) {
-  switch (type) {
-    case "complementary":
-      return [complementaryHsl(color)];
-    case "complementary-lab":
-      return [complementaryLab(color)];
-    case "complementary-lch":
-      return [complementaryLch(color)];
-    case "split-complementary":
-      return splitComplementaryHsl(color);
-    case "split-complementary-lab":
-      return splitComplementaryLab(color);
-    case "split-complementary-lch":
-      return splitComplementaryLch(color);
-    case "triadic":
-      return triadicHsl(color);
-    case "triadic-lab":
-      return triadicLab(color);
-    case "triadic-lch":
-      return triadicLch(color);
-    case "tetradic":
-      return tetradicHsl(color);
-    case "tetradic-lab":
-      return tetradicLab(color);
-    case "tetradic-lch":
-      return tetradicLch(color);
-    default:
-      throw new Error(`Invalid palette type: ${type}`);
-  }
+/**
+ * Generates a color palette based on color theory harmony rules.
+ *
+ * @template C - The input color type.
+ * @template T - The palette generation scheme type.
+ * @param {C} color - The base color for palette generation.
+ * @param {T} type - The type of palette to generate (e.g., 'complementary', 'triadic', 'tetradic').
+ * @returns {Palette<C, T>} An array of colors forming the requested palette, in the original color format.
+ */
+export function palette(color, type) {
+    switch (type) {
+        case 'complementary': return [complementaryHsl(color)];
+        case 'complementary-lab': return [complementaryLab(color)];
+        case 'complementary-lch': return [complementaryLch(color)];
+        case 'split-complementary': return splitComplementaryHsl(color);
+        case 'split-complementary-lab': return splitComplementaryLab(color);
+        case 'split-complementary-lch': return splitComplementaryLch(color);
+        case 'triadic': return triadicHsl(color);
+        case 'triadic-lab': return triadicLab(color);
+        case 'triadic-lch': return triadicLch(color);
+        case 'tetradic': return tetradicHsl(color);
+        case 'tetradic-lab': return tetradicLab(color);
+        case 'tetradic-lch': return tetradicLch(color);
+        default: throw new Error(`Invalid palette type: ${type}`);
+    }
 }
-export {
-  palette
-};