@newtonedev/colors 0.0.1

package/dist/hue-grade.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Global hue grading — shifts each palette's base hue toward shared
+ * "light" and "dark" grade hues at the scale endpoints.
+ *
+ * Light grading fades from full at the lightest step to zero at GRADE_REACH.
+ * Dark grading fades from zero at (1 - GRADE_REACH) to full at the darkest step.
+ * In the overlap zone, both shifts are additive (commutative).
+ */
+/** How far each global grade reaches into the scale (0–1, from its respective end). */
+export declare const GRADE_REACH: number;
+/** Maximum allowed intensity for global grading. */
+export declare const MAX_GRADE_INTENSITY = 0.25;
+/** How far a local (per-palette) grade reaches into the scale (0–1, from its end). */
+export declare const LOCAL_GRADE_REACH: number;
+/** Maximum allowed intensity for local grading. */
+export declare const MAX_LOCAL_GRADE_INTENSITY = 0.5;
+export interface HueGrade {
+    /** Target hue for the light end (0–360°). */
+    readonly lightHue: number;
+    /** Blend intensity for the light end (0–MAX_GRADE_INTENSITY). */
+    readonly lightIntensity: number;
+    /** Target hue for the dark end (0–360°). */
+    readonly darkHue: number;
+    /** Blend intensity for the dark end (0–MAX_GRADE_INTENSITY). */
+    readonly darkIntensity: number;
+}
+/**
+ * Compute the graded hue at position `t` in the scale.
+ *
+ * Uses vector interpolation in Cartesian space rather than angular deltas
+ * to avoid the shortest-arc discontinuity at 180° (where the direction
+ * of rotation flips abruptly). Each grade's displacement is computed as
+ * a vector offset from the base hue, and displacements are additive
+ * (commutative — order doesn't matter).
+ *
+ * @param baseHue       The palette's own hue (0–360°).
+ * @param t             Position in the scale: 0 = lightest, 1 = darkest.
+ * @param grade         Hue grade configuration.
+ * @param reach         How far each grade reaches into the scale (default: GRADE_REACH).
+ * @param maxIntensity  Maximum intensity clamp (default: MAX_GRADE_INTENSITY).
+ * @returns             The graded hue in degrees (0–360).
+ */
+export declare function gradeHue(baseHue: number, t: number, grade: HueGrade, reach?: number, maxIntensity?: number): number;
+/**
+ * Resolve the final hue at position `t`, applying global then local grading.
+ *
+ * This is the canonical composition: global grade (using GRADE_REACH /
+ * MAX_GRADE_INTENSITY) first, then local grade (using LOCAL_GRADE_REACH /
+ * MAX_LOCAL_GRADE_INTENSITY) on the already-shifted result.
+ *
+ * @param baseHue      The palette's own hue (0–360°).
+ * @param t            Position in the scale: 0 = lightest, 1 = darkest.
+ * @param globalGrade  Global hue grade (shared across palettes), or undefined.
+ * @param localGrade   Local hue grade (per-palette, typically one-sided), or undefined.
+ * @returns            The fully graded hue in degrees (0–360).
+ */
+export declare function resolveGradedHue(baseHue: number, t: number, globalGrade?: HueGrade, localGrade?: HueGrade): number;
+/**
+ * Build a one-sided HueGrade (only light or dark active).
+ *
+ * @param hue        Target hue for the active side (0–360°).
+ * @param intensity  Blend intensity for the active side.
+ * @param side       Which end of the scale to affect.
+ */
+export declare function buildOneSidedGrade(hue: number, intensity: number, side: "light" | "dark"): HueGrade;
+//# sourceMappingURL=hue-grade.d.ts.map

package/dist/hue-grade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hue-grade.d.ts","sourceRoot":"","sources":["../src/hue-grade.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,uFAAuF;AACvF,eAAO,MAAM,WAAW,QAAQ,CAAC;AAEjC,oDAAoD;AACpD,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,sFAAsF;AACtF,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AAEvC,mDAAmD;AACnD,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,MAAM,WAAW,QAAQ;IACvB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,QAAQ,EACf,KAAK,GAAE,MAAoB,EAC3B,YAAY,GAAE,MAA4B,GACzC,MAAM,CAoDR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,EACT,WAAW,CAAC,EAAE,QAAQ,EACtB,UAAU,CAAC,EAAE,QAAQ,GACpB,MAAM,CAKR;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,OAAO,GAAG,MAAM,GACrB,QAAQ,CAIV"}

package/dist/index.cjs

@@ -0,0 +1,602 @@
+'use strict';
+
+// src/constants.ts
+var SRGB_GAMMA_THRESHOLD = 0.04045;
+var SRGB_GAMMA_THRESHOLD_LINEAR = 31308e-7;
+var SRGB_GAMMA_SLOPE = 12.92;
+var SRGB_GAMMA_EXPONENT = 2.4;
+var SRGB_GAMMA_OFFSET = 0.055;
+var SRGB_GAMMA_SCALE = 1.055;
+var LINEAR_SRGB_TO_LMS = [
+  [0.4122214708, 0.5363325363, 0.0514459929],
+  [0.2119034982, 0.6806995451, 0.1073969566],
+  [0.0883024619, 0.2817188376, 0.6299787005]
+];
+var LMS_PRIME_TO_OKLAB = [
+  [0.2104542553, 0.793617785, -0.0040720468],
+  [1.9779984951, -2.428592205, 0.4505937099],
+  [0.0259040371, 0.7827717662, -0.808675766]
+];
+var OKLAB_TO_LMS_PRIME = [
+  [1, 0.3963377774, 0.2158037573],
+  [1, -0.1055613458, -0.0638541728],
+  [1, -0.0894841775, -1.291485548]
+];
+var LMS_TO_LINEAR_SRGB = [
+  [4.0767416621, -3.3077115913, 0.2309699292],
+  [-1.2684380046, 2.6097574011, -0.3413193965],
+  [-0.0041960863, -0.7034186147, 1.707614701]
+];
+var LINEAR_P3_TO_LMS = [
+  [0.4813791595, 0.4621155872, 0.0565406381],
+  [0.2288319169, 0.6532167007, 0.1179528072],
+  [0.0839457149, 0.2241651052, 0.6918912614]
+];
+var LMS_TO_LINEAR_P3 = [
+  [3.127769439, -2.2570600176, 0.1291828502],
+  [-1.0910091977, 2.4133065499, -0.3222615148],
+  [-0.0260108068, -0.5080402362, 1.5340494942]
+];
+var GAMUT_EPSILON = 1e-6;
+var GAMUT_MAP_JND = 0.02;
+var GAMUT_MAP_EPSILON = 1e-4;
+var GAMUT_MAP_MAX_ITERATIONS = 50;
+var ACHROMATIC_THRESHOLD = 1e-10;
+var WCAG_R = 0.2126;
+var WCAG_G = 0.7152;
+var WCAG_B = 0.0722;
+var APCA_MAIN_TRC = 2.4;
+var APCA_SRGB_R = 0.2126729;
+var APCA_SRGB_G = 0.7151522;
+var APCA_SRGB_B = 0.072175;
+var APCA_NORM_BG = 0.56;
+var APCA_NORM_TXT = 0.57;
+var APCA_REV_TXT = 0.62;
+var APCA_REV_BG = 0.65;
+var APCA_BLK_THRS = 0.022;
+var APCA_BLK_CLMP = 1.414;
+var APCA_SCALE_BOW = 1.14;
+var APCA_SCALE_WOB = 1.14;
+var APCA_LO_BOW_OFFSET = 0.027;
+var APCA_LO_WOB_OFFSET = 0.027;
+var APCA_DELTA_Y_MIN = 5e-4;
+var APCA_LO_CLIP = 0.1;
+var DEG_TO_RAD = Math.PI / 180;
+var RAD_TO_DEG = 180 / Math.PI;
+
+// src/conversions/oklab.ts
+function oklabToOklch(lab) {
+  const C = Math.sqrt(lab.a * lab.a + lab.b * lab.b);
+  if (C < ACHROMATIC_THRESHOLD) {
+    return { L: lab.L, C: 0, h: 0 };
+  }
+  let h = Math.atan2(lab.b, lab.a) * RAD_TO_DEG;
+  if (h < 0) h += 360;
+  return { L: lab.L, C, h };
+}
+function oklchToOklab(lch) {
+  const hRad = lch.h * DEG_TO_RAD;
+  return {
+    L: lch.L,
+    a: lch.C * Math.cos(hRad),
+    b: lch.C * Math.sin(hRad)
+  };
+}
+
+// src/conversions/linear-srgb.ts
+function linearSrgbToOklab(color) {
+  const l = LINEAR_SRGB_TO_LMS[0][0] * color.r + LINEAR_SRGB_TO_LMS[0][1] * color.g + LINEAR_SRGB_TO_LMS[0][2] * color.b;
+  const m = LINEAR_SRGB_TO_LMS[1][0] * color.r + LINEAR_SRGB_TO_LMS[1][1] * color.g + LINEAR_SRGB_TO_LMS[1][2] * color.b;
+  const s = LINEAR_SRGB_TO_LMS[2][0] * color.r + LINEAR_SRGB_TO_LMS[2][1] * color.g + LINEAR_SRGB_TO_LMS[2][2] * color.b;
+  const lp = Math.cbrt(l);
+  const mp = Math.cbrt(m);
+  const sp = Math.cbrt(s);
+  return {
+    L: LMS_PRIME_TO_OKLAB[0][0] * lp + LMS_PRIME_TO_OKLAB[0][1] * mp + LMS_PRIME_TO_OKLAB[0][2] * sp,
+    a: LMS_PRIME_TO_OKLAB[1][0] * lp + LMS_PRIME_TO_OKLAB[1][1] * mp + LMS_PRIME_TO_OKLAB[1][2] * sp,
+    b: LMS_PRIME_TO_OKLAB[2][0] * lp + LMS_PRIME_TO_OKLAB[2][1] * mp + LMS_PRIME_TO_OKLAB[2][2] * sp
+  };
+}
+function oklabToLinearSrgb(color) {
+  const lp = OKLAB_TO_LMS_PRIME[0][0] * color.L + OKLAB_TO_LMS_PRIME[0][1] * color.a + OKLAB_TO_LMS_PRIME[0][2] * color.b;
+  const mp = OKLAB_TO_LMS_PRIME[1][0] * color.L + OKLAB_TO_LMS_PRIME[1][1] * color.a + OKLAB_TO_LMS_PRIME[1][2] * color.b;
+  const sp = OKLAB_TO_LMS_PRIME[2][0] * color.L + OKLAB_TO_LMS_PRIME[2][1] * color.a + OKLAB_TO_LMS_PRIME[2][2] * color.b;
+  const l = lp * lp * lp;
+  const m = mp * mp * mp;
+  const s = sp * sp * sp;
+  return {
+    r: LMS_TO_LINEAR_SRGB[0][0] * l + LMS_TO_LINEAR_SRGB[0][1] * m + LMS_TO_LINEAR_SRGB[0][2] * s,
+    g: LMS_TO_LINEAR_SRGB[1][0] * l + LMS_TO_LINEAR_SRGB[1][1] * m + LMS_TO_LINEAR_SRGB[1][2] * s,
+    b: LMS_TO_LINEAR_SRGB[2][0] * l + LMS_TO_LINEAR_SRGB[2][1] * m + LMS_TO_LINEAR_SRGB[2][2] * s
+  };
+}
+
+// src/conversions/linear-p3.ts
+function linearP3ToOklab(color) {
+  const l = LINEAR_P3_TO_LMS[0][0] * color.r + LINEAR_P3_TO_LMS[0][1] * color.g + LINEAR_P3_TO_LMS[0][2] * color.b;
+  const m = LINEAR_P3_TO_LMS[1][0] * color.r + LINEAR_P3_TO_LMS[1][1] * color.g + LINEAR_P3_TO_LMS[1][2] * color.b;
+  const s = LINEAR_P3_TO_LMS[2][0] * color.r + LINEAR_P3_TO_LMS[2][1] * color.g + LINEAR_P3_TO_LMS[2][2] * color.b;
+  const lp = Math.cbrt(l);
+  const mp = Math.cbrt(m);
+  const sp = Math.cbrt(s);
+  return {
+    L: LMS_PRIME_TO_OKLAB[0][0] * lp + LMS_PRIME_TO_OKLAB[0][1] * mp + LMS_PRIME_TO_OKLAB[0][2] * sp,
+    a: LMS_PRIME_TO_OKLAB[1][0] * lp + LMS_PRIME_TO_OKLAB[1][1] * mp + LMS_PRIME_TO_OKLAB[1][2] * sp,
+    b: LMS_PRIME_TO_OKLAB[2][0] * lp + LMS_PRIME_TO_OKLAB[2][1] * mp + LMS_PRIME_TO_OKLAB[2][2] * sp
+  };
+}
+function oklabToLinearP3(color) {
+  const lp = OKLAB_TO_LMS_PRIME[0][0] * color.L + OKLAB_TO_LMS_PRIME[0][1] * color.a + OKLAB_TO_LMS_PRIME[0][2] * color.b;
+  const mp = OKLAB_TO_LMS_PRIME[1][0] * color.L + OKLAB_TO_LMS_PRIME[1][1] * color.a + OKLAB_TO_LMS_PRIME[1][2] * color.b;
+  const sp = OKLAB_TO_LMS_PRIME[2][0] * color.L + OKLAB_TO_LMS_PRIME[2][1] * color.a + OKLAB_TO_LMS_PRIME[2][2] * color.b;
+  const l = lp * lp * lp;
+  const m = mp * mp * mp;
+  const s = sp * sp * sp;
+  return {
+    r: LMS_TO_LINEAR_P3[0][0] * l + LMS_TO_LINEAR_P3[0][1] * m + LMS_TO_LINEAR_P3[0][2] * s,
+    g: LMS_TO_LINEAR_P3[1][0] * l + LMS_TO_LINEAR_P3[1][1] * m + LMS_TO_LINEAR_P3[1][2] * s,
+    b: LMS_TO_LINEAR_P3[2][0] * l + LMS_TO_LINEAR_P3[2][1] * m + LMS_TO_LINEAR_P3[2][2] * s
+  };
+}
+
+// src/conversions/srgb.ts
+function srgbChannelToLinear(value) {
+  return value <= SRGB_GAMMA_THRESHOLD ? value / SRGB_GAMMA_SLOPE : ((value + SRGB_GAMMA_OFFSET) / SRGB_GAMMA_SCALE) ** SRGB_GAMMA_EXPONENT;
+}
+function linearChannelToSrgb(value) {
+  return value <= SRGB_GAMMA_THRESHOLD_LINEAR ? value * SRGB_GAMMA_SLOPE : SRGB_GAMMA_SCALE * value ** (1 / SRGB_GAMMA_EXPONENT) - SRGB_GAMMA_OFFSET;
+}
+function srgbToLinearSrgb(color) {
+  return {
+    r: srgbChannelToLinear(color.r),
+    g: srgbChannelToLinear(color.g),
+    b: srgbChannelToLinear(color.b)
+  };
+}
+function linearSrgbToSrgb(color) {
+  return {
+    r: linearChannelToSrgb(color.r),
+    g: linearChannelToSrgb(color.g),
+    b: linearChannelToSrgb(color.b)
+  };
+}
+
+// src/conversions/hex.ts
+function hexToSrgb(hex) {
+  let h = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (h.length === 3) {
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  }
+  const n = parseInt(h, 16);
+  return {
+    r: (n >> 16 & 255) / 255,
+    g: (n >> 8 & 255) / 255,
+    b: (n & 255) / 255
+  };
+}
+function srgbToHex(color) {
+  const r = Math.round(Math.max(0, Math.min(1, color.r)) * 255);
+  const g = Math.round(Math.max(0, Math.min(1, color.g)) * 255);
+  const b = Math.round(Math.max(0, Math.min(1, color.b)) * 255);
+  return `#${(1 << 24 | r << 16 | g << 8 | b).toString(16).slice(1)}`;
+}
+
+// src/conversions/pipeline.ts
+function srgbToOklch(color) {
+  return oklabToOklch(linearSrgbToOklab(srgbToLinearSrgb(color)));
+}
+function oklchToSrgb(color) {
+  return linearSrgbToSrgb(oklabToLinearSrgb(oklchToOklab(color)));
+}
+function srgbToOklab(color) {
+  return linearSrgbToOklab(srgbToLinearSrgb(color));
+}
+function oklabToSrgb(color) {
+  return linearSrgbToSrgb(oklabToLinearSrgb(color));
+}
+function hexToOklch(hex) {
+  return srgbToOklch(hexToSrgb(hex));
+}
+function oklchToHex(color) {
+  const srgb = oklchToSrgb(color);
+  return srgbToHex({
+    r: Math.max(0, Math.min(1, srgb.r)),
+    g: Math.max(0, Math.min(1, srgb.g)),
+    b: Math.max(0, Math.min(1, srgb.b))
+  });
+}
+function p3ToOklch(color) {
+  return oklabToOklch(linearP3ToOklab(srgbToLinearSrgb(color)));
+}
+function oklchToP3(color) {
+  return linearSrgbToSrgb(oklabToLinearP3(oklchToOklab(color)));
+}
+
+// src/gamut/check.ts
+function isInGamut(color) {
+  return color.r >= -GAMUT_EPSILON && color.r <= 1 + GAMUT_EPSILON && color.g >= -GAMUT_EPSILON && color.g <= 1 + GAMUT_EPSILON && color.b >= -GAMUT_EPSILON && color.b <= 1 + GAMUT_EPSILON;
+}
+function clampSrgb(color) {
+  return {
+    r: Math.max(0, Math.min(1, color.r)),
+    g: Math.max(0, Math.min(1, color.g)),
+    b: Math.max(0, Math.min(1, color.b))
+  };
+}
+
+// src/color/difference.ts
+function deltaEOK(a, b) {
+  return deltaEOKLab(oklchToOklab(a), oklchToOklab(b));
+}
+function deltaEOKLab(a, b) {
+  const dL = a.L - b.L;
+  const da = a.a - b.a;
+  const db = a.b - b.b;
+  return Math.sqrt(dL * dL + da * da + db * db);
+}
+
+// src/gamut/map.ts
+function gamutMap(color, gamut = "srgb") {
+  const toRgb = gamut === "display-p3" ? oklchToP3 : oklchToSrgb;
+  const rgbToOklab = gamut === "display-p3" ? (c) => linearP3ToOklab(srgbToLinearSrgb(c)) : (c) => linearSrgbToOklab(srgbToLinearSrgb(c));
+  const rgb = toRgb(color);
+  if (isInGamut(rgb)) return color;
+  if (color.L <= GAMUT_EPSILON) return { L: 0, C: 0, h: color.h };
+  if (color.L >= 1 - GAMUT_EPSILON) return { L: 1, C: 0, h: color.h };
+  let lo = 0;
+  let hi = color.C;
+  for (let i = 0; i < GAMUT_MAP_MAX_ITERATIONS; i++) {
+    const midC = (lo + hi) / 2;
+    const candidate = { L: color.L, C: midC, h: color.h };
+    const candidateRgb = toRgb(candidate);
+    if (isInGamut(candidateRgb)) {
+      lo = midC;
+    } else {
+      const clipped = clampSrgb(candidateRgb);
+      const clippedLab = rgbToOklab(clipped);
+      const candidateLab = oklchToOklab(candidate);
+      const dE = deltaEOKLab(clippedLab, candidateLab);
+      if (dE < GAMUT_MAP_JND) {
+        break;
+      }
+      hi = midC;
+    }
+    if (hi - lo < GAMUT_MAP_EPSILON) break;
+  }
+  return { L: color.L, C: lo, h: color.h };
+}
+
+// src/gamut/max-chroma.ts
+function maxChroma(L, h, gamut = "srgb") {
+  if (L <= 0 || L >= 1) return 0;
+  const toRgb = gamut === "display-p3" ? oklchToP3 : oklchToSrgb;
+  let lo = 0;
+  let hi = gamut === "display-p3" ? 0.5 : 0.4;
+  for (let i = 0; i < GAMUT_MAP_MAX_ITERATIONS; i++) {
+    const mid = (lo + hi) / 2;
+    const color = { L, C: mid, h };
+    const rgb = toRgb(color);
+    if (isInGamut(rgb)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+    if (hi - lo < 1e-6) break;
+  }
+  return lo;
+}
+
+// src/contrast/wcag.ts
+function wcagLuminance(color) {
+  return WCAG_R * srgbChannelToLinear(color.r) + WCAG_G * srgbChannelToLinear(color.g) + WCAG_B * srgbChannelToLinear(color.b);
+}
+function wcagContrast(a, b) {
+  const lA = wcagLuminance(a);
+  const lB = wcagLuminance(b);
+  const lighter = Math.max(lA, lB);
+  const darker = Math.min(lA, lB);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function contrastTextHex(background) {
+  const white = { r: 1, g: 1, b: 1 };
+  const black = { r: 0, g: 0, b: 0 };
+  return wcagContrast(white, background) > wcagContrast(black, background) ? "#ffffff" : "#000000";
+}
+
+// src/contrast/apca.ts
+function apcaContrast(textColor, bgColor) {
+  let txtY = APCA_SRGB_R * textColor.r ** APCA_MAIN_TRC + APCA_SRGB_G * textColor.g ** APCA_MAIN_TRC + APCA_SRGB_B * textColor.b ** APCA_MAIN_TRC;
+  let bgY = APCA_SRGB_R * bgColor.r ** APCA_MAIN_TRC + APCA_SRGB_G * bgColor.g ** APCA_MAIN_TRC + APCA_SRGB_B * bgColor.b ** APCA_MAIN_TRC;
+  if (txtY < APCA_BLK_THRS) {
+    txtY += (APCA_BLK_THRS - txtY) ** APCA_BLK_CLMP;
+  }
+  if (bgY < APCA_BLK_THRS) {
+    bgY += (APCA_BLK_THRS - bgY) ** APCA_BLK_CLMP;
+  }
+  if (Math.abs(bgY - txtY) < APCA_DELTA_Y_MIN) return 0;
+  let sapc;
+  if (bgY > txtY) {
+    sapc = (bgY ** APCA_NORM_BG - txtY ** APCA_NORM_TXT) * APCA_SCALE_BOW;
+    return sapc < APCA_LO_CLIP ? 0 : (sapc - APCA_LO_BOW_OFFSET) * 100;
+  } else {
+    sapc = (bgY ** APCA_REV_BG - txtY ** APCA_REV_TXT) * APCA_SCALE_WOB;
+    return sapc > -APCA_LO_CLIP ? 0 : (sapc + APCA_LO_WOB_OFFSET) * 100;
+  }
+}
+
+// src/color/interpolation.ts
+function mix(a, b, t) {
+  const L = a.L + (b.L - a.L) * t;
+  const C = a.C + (b.C - a.C) * t;
+  const aIsAchromatic = a.C < ACHROMATIC_THRESHOLD;
+  const bIsAchromatic = b.C < ACHROMATIC_THRESHOLD;
+  if (aIsAchromatic && bIsAchromatic) {
+    return { L, C, h: 0 };
+  }
+  const hA = aIsAchromatic ? b.h : a.h;
+  const hB = bIsAchromatic ? a.h : b.h;
+  let delta = hB - hA;
+  if (delta > 180) delta -= 360;
+  if (delta < -180) delta += 360;
+  let h = hA + delta * t;
+  if (h < 0) h += 360;
+  if (h >= 360) h -= 360;
+  return { L, C, h };
+}
+
+// src/config.ts
+var MIN_LIGHTEST_L = 0.96;
+var MAX_DARKEST_L = 0.16;
+var GRADE_REACH = 3 / 5;
+var MAX_GRADE_INTENSITY = 0.25;
+var LOCAL_GRADE_REACH = 2 / 3;
+var MAX_LOCAL_GRADE_INTENSITY = 0.5;
+var PERCEPTUAL_JND = 0.02;
+
+// src/scale/hue-grade.ts
+function gradeHue(baseHue, t, grade, reach = GRADE_REACH, maxIntensity = MAX_GRADE_INTENSITY) {
+  const { lightHue, lightValue, darkHue, darkValue } = grade;
+  const li = Math.max(0, Math.min(maxIntensity, lightValue));
+  const di = Math.max(0, Math.min(maxIntensity, darkValue));
+  if (li === 0 && di === 0) return baseHue;
+  const lightInfluence = t <= reach ? 0.5 * (1 + Math.cos(Math.PI * t / reach)) : 0;
+  const darkInfluence = t >= 1 - reach ? 0.5 * (1 + Math.cos(Math.PI * (1 - t) / reach)) : 0;
+  const toRad = Math.PI / 180;
+  const baseRad = baseHue * toRad;
+  const bx = Math.cos(baseRad);
+  const by = Math.sin(baseRad);
+  let dx = 0;
+  let dy = 0;
+  if (lightInfluence > 0 && li > 0) {
+    const blend = lightInfluence * li;
+    const lRad = lightHue * toRad;
+    dx += blend * (Math.cos(lRad) - bx);
+    dy += blend * (Math.sin(lRad) - by);
+  }
+  if (darkInfluence > 0 && di > 0) {
+    const blend = darkInfluence * di;
+    const dRad = darkHue * toRad;
+    dx += blend * (Math.cos(dRad) - bx);
+    dy += blend * (Math.sin(dRad) - by);
+  }
+  const rx = bx + dx;
+  const ry = by + dy;
+  if (rx * rx + ry * ry < 1e-20) return baseHue;
+  return (Math.atan2(ry, rx) / toRad + 360) % 360;
+}
+function resolveGradedHue(baseHue, t, globalGrade, localGrade) {
+  let h = baseHue;
+  if (globalGrade) h = gradeHue(h, t, globalGrade);
+  if (localGrade) h = gradeHue(h, t, localGrade, LOCAL_GRADE_REACH, MAX_LOCAL_GRADE_INTENSITY);
+  return h;
+}
+function buildOneSidedGrade(hue, value, side) {
+  return side === "light" ? { lightHue: hue, lightValue: value, darkHue: 0, darkValue: 0 } : { lightHue: 0, lightValue: 0, darkHue: hue, darkValue: value };
+}
+
+// src/scale/generate.ts
+function generateScale(options) {
+  const {
+    hue,
+    steps,
+    chroma,
+    gamut = "srgb",
+    lightest = 1,
+    darkest = 0,
+    grading,
+    gradient
+  } = options;
+  const chromaRatio = chroma?.value ?? 1;
+  const chromaPeak = chroma?.offset ?? 0.5;
+  const hueGrade = grading;
+  const localHueGrade = gradient ? buildOneSidedGrade(gradient.hue, gradient.value, gradient.direction) : void 0;
+  if (steps < 2) return [];
+  const ratio = Math.max(0, Math.min(1, chromaRatio));
+  const peak = Math.max(0, Math.min(1, chromaPeak));
+  const lightestL = Math.max(0, Math.min(1, lightest));
+  const darkestL = Math.max(0, Math.min(1, darkest));
+  const hueAt = (t) => resolveGradedHue(hue, t, hueGrade, localHueGrade);
+  if (peak === 0.5 || ratio === 0 || ratio >= 1) {
+    const scale2 = [];
+    for (let i = 0; i < steps; i++) {
+      const t = i / (steps - 1);
+      const L = lightestL - t * (lightestL - darkestL);
+      const h = hueAt(t);
+      const C = maxChroma(L, h, gamut) * ratio;
+      scale2.push({ L, C, h });
+    }
+    return scale2;
+  }
+  const N = 100;
+  let peakT = 0.5;
+  let peakBoundaryC = 0;
+  const boundarySamples = [];
+  for (let i = 0; i <= N; i++) {
+    const t = i / N;
+    const L = lightestL - t * (lightestL - darkestL);
+    const C = maxChroma(L, hueAt(t), gamut);
+    boundarySamples.push({ t, C });
+    if (C > peakBoundaryC) {
+      peakBoundaryC = C;
+      peakT = t;
+    }
+  }
+  const innerPeakC = peakBoundaryC * ratio;
+  let validMinT = peakT;
+  let validMaxT = peakT;
+  for (const { t, C } of boundarySamples) {
+    if (C >= innerPeakC - 1e-6) {
+      if (t < validMinT) validMinT = t;
+      if (t > validMaxT) validMaxT = t;
+    }
+  }
+  let targetT;
+  if (peak <= 0.5) {
+    targetT = validMinT + peak / 0.5 * (peakT - validMinT);
+  } else {
+    targetT = peakT + (peak - 0.5) / 0.5 * (validMaxT - peakT);
+  }
+  if (targetT <= 0 || targetT >= 1) {
+    targetT = peakT;
+  }
+  const scale = [];
+  for (let i = 0; i < steps; i++) {
+    const t = i / (steps - 1);
+    const L = lightestL - t * (lightestL - darkestL);
+    const h = hueAt(t);
+    let tWarped;
+    if (t <= targetT) {
+      tWarped = t * (peakT / targetT);
+    } else {
+      tWarped = peakT + (t - targetT) * ((1 - peakT) / (1 - targetT));
+    }
+    const Lwarped = lightestL - tWarped * (lightestL - darkestL);
+    const warpedC = maxChroma(Lwarped, hueAt(tWarped), gamut) * ratio;
+    const boundaryC = maxChroma(L, h, gamut);
+    const C = Math.min(warpedC, boundaryC);
+    scale.push({ L, C, h });
+  }
+  return scale;
+}
+
+// src/scale/resolve-color.ts
+function resolveColor(input, gamut = "srgb") {
+  const isHex = typeof input === "string";
+  const original = isHex ? hexToOklch(input) : input;
+  let inGamut;
+  if (isHex) {
+    inGamut = true;
+  } else {
+    const rgb = gamut === "display-p3" ? oklchToP3(original) : oklchToSrgb(original);
+    inGamut = isInGamut(rgb);
+  }
+  const oklch = inGamut ? original : gamutMap(original, gamut);
+  const boundary = maxChroma(oklch.L, oklch.h, gamut);
+  const chromaRatio = boundary > 0 ? oklch.C / boundary : 0;
+  return {
+    oklch,
+    hex: oklchToHex(oklch),
+    wasRemapped: !inGamut,
+    original,
+    chromaShift: original.C - oklch.C,
+    hue: oklch.h,
+    chromaRatio: Math.min(1, chromaRatio)
+  };
+}
+function findNearest(target, scale) {
+  if (scale.length === 0) {
+    throw new Error("findNearest: scale must not be empty");
+  }
+  let bestIndex = 0;
+  let bestDistance = Infinity;
+  for (let i = 0; i < scale.length; i++) {
+    const d = deltaEOK(target, scale[i]);
+    if (d < bestDistance) {
+      bestDistance = d;
+      bestIndex = i;
+    }
+  }
+  return {
+    index: bestIndex,
+    color: scale[bestIndex],
+    distance: bestDistance
+  };
+}
+
+// src/scale/dynamic-range.ts
+function resolveLightest(slider) {
+  const s = Math.max(0, Math.min(1, slider));
+  return MIN_LIGHTEST_L + s * (1 - MIN_LIGHTEST_L);
+}
+function resolveDarkest(slider) {
+  const s = Math.max(0, Math.min(1, slider));
+  return MAX_DARKEST_L * (1 - s);
+}
+function lightnessToScaleT(L, lightestL, darkestL) {
+  const range = lightestL - darkestL;
+  if (range <= 0) return 0.5;
+  return Math.max(0, Math.min(1, (lightestL - L) / range));
+}
+
+// src/scale/key-color.ts
+function keyColor(color, options) {
+  const { gamut = "srgb", lightest = 1, darkest = 0 } = options ?? {};
+  const resolved = resolveColor(color, gamut);
+  const offset = lightnessToScaleT(resolved.oklch.L, lightest, darkest);
+  return {
+    hue: resolved.hue,
+    chroma: { value: resolved.chromaRatio, offset },
+    resolved
+  };
+}
+
+exports.GRADE_REACH = GRADE_REACH;
+exports.LOCAL_GRADE_REACH = LOCAL_GRADE_REACH;
+exports.MAX_DARKEST_L = MAX_DARKEST_L;
+exports.MAX_GRADE_INTENSITY = MAX_GRADE_INTENSITY;
+exports.MAX_LOCAL_GRADE_INTENSITY = MAX_LOCAL_GRADE_INTENSITY;
+exports.MIN_LIGHTEST_L = MIN_LIGHTEST_L;
+exports.PERCEPTUAL_JND = PERCEPTUAL_JND;
+exports.apcaContrast = apcaContrast;
+exports.buildOneSidedGrade = buildOneSidedGrade;
+exports.clampSrgb = clampSrgb;
+exports.contrastTextHex = contrastTextHex;
+exports.deltaEOK = deltaEOK;
+exports.deltaEOKLab = deltaEOKLab;
+exports.findNearest = findNearest;
+exports.gamutMap = gamutMap;
+exports.generateScale = generateScale;
+exports.gradeHue = gradeHue;
+exports.hexToOklch = hexToOklch;
+exports.hexToSrgb = hexToSrgb;
+exports.isInGamut = isInGamut;
+exports.keyColor = keyColor;
+exports.lightnessToScaleT = lightnessToScaleT;
+exports.linearChannelToSrgb = linearChannelToSrgb;
+exports.linearP3ToOklab = linearP3ToOklab;
+exports.linearSrgbToOklab = linearSrgbToOklab;
+exports.linearSrgbToSrgb = linearSrgbToSrgb;
+exports.maxChroma = maxChroma;
+exports.mix = mix;
+exports.oklabToLinearP3 = oklabToLinearP3;
+exports.oklabToLinearSrgb = oklabToLinearSrgb;
+exports.oklabToOklch = oklabToOklch;
+exports.oklabToSrgb = oklabToSrgb;
+exports.oklchToHex = oklchToHex;
+exports.oklchToOklab = oklchToOklab;
+exports.oklchToP3 = oklchToP3;
+exports.oklchToSrgb = oklchToSrgb;
+exports.p3ToOklch = p3ToOklch;
+exports.resolveColor = resolveColor;
+exports.resolveDarkest = resolveDarkest;
+exports.resolveGradedHue = resolveGradedHue;
+exports.resolveLightest = resolveLightest;
+exports.srgbChannelToLinear = srgbChannelToLinear;
+exports.srgbToHex = srgbToHex;
+exports.srgbToLinearSrgb = srgbToLinearSrgb;
+exports.srgbToOklab = srgbToOklab;
+exports.srgbToOklch = srgbToOklch;
+exports.wcagContrast = wcagContrast;
+exports.wcagLuminance = wcagLuminance;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map