@soybeanjs/colord 0.0.7 → 0.0.8

package/dist/{colord-CLzIbIN2.js → colord-CiL21DdP.js}

@@ -1,8 +1,8 @@
-import { l as round, v as ALPHA_PRECISION } from "./utils-CshL9w1R.js";
-import { a as parseRgbString, c as roundRgb, i as parseRgb, s as rgbToRgbString } from "./rgb-BVkoWOmR.js";
-import { i as roundHsv, n as parseHsv, r as rgbToHsv } from "./hsv-OOAVcaRH.js";
-import { a as saturate, c as rgbToHsl, l as rgbToHslString, n as invert, o as parseHsl, r as lighten, s as parseHslString, t as changeAlpha, u as roundHsl } from "./manipulate-DCHNBCkU.js";
-import { t as getBrightness } from "./get-SLuYLSG9.js";
+import { l as round, v as ALPHA_PRECISION } from "./utils-BhDL0kto.js";
+import { a as parseRgbString, c as roundRgb, i as parseRgb, s as rgbToRgbString } from "./rgb-BIWjP3hJ.js";
+import { i as roundHsv, n as parseHsv, r as rgbToHsv } from "./hsv-6f-Avk00.js";
+import { a as saturate, c as rgbToHsl, l as rgbToHslString, n as invert, o as parseHsl, r as lighten, s as parseHslString, t as changeAlpha, u as roundHsl } from "./manipulate-DJ-cBonL.js";
+import { t as getBrightness } from "./get-DjkEJgax.js";
 
 //#region src/models/hex.ts
 const hexMatcher = /^#([0-9a-f]{3,8})$/i;
@@ -37,6 +37,12 @@ const rgbToHex = (rgb) => {
 	return `#${format(r)}${format(g)}${format(b)}${alphaHex}`;
 };
 
+//#endregion
+//#region src/shared/common.ts
+function keysOf(record) {
+	return Object.keys(record);
+}
+
 //#endregion
 //#region src/shared/parse.ts
 const parsers = {
@@ -249,4 +255,4 @@ var Colord = class {
 };
 
 //#endregion
-export { parsers as a, getFormat as i, colord as n, random as r, Colord as t };
+export { parsers as a, getFormat as i, colord as n, keysOf as o, random as r, Colord as t };

package/dist/{colord-Dc09uNcG.d.ts → colord-DjohCNUk.d.ts}

@@ -1,70 +1,7 @@
-//#region src/types.d.ts
-type WithAlpha<O> = O & {
-  alpha: number;
-};
-type RgbColor = WithAlpha<{
-  r: number;
-  g: number;
-  b: number;
-}>;
-type HslColor = WithAlpha<{
-  h: number;
-  s: number;
-  l: number;
-}>;
-type HsvColor = WithAlpha<{
-  h: number;
-  s: number;
-  v: number;
-}>;
-type HwbColor = WithAlpha<{
-  h: number;
-  w: number;
-  b: number;
-}>;
-type XyzColor = WithAlpha<{
-  x: number;
-  y: number;
-  z: number;
-}>;
-type LabColor = WithAlpha<{
-  l: number;
-  a: number;
-  b: number;
-}>;
-type LchColor = WithAlpha<{
-  l: number;
-  c: number;
-  h: number;
-}>;
-type CmykColor = WithAlpha<{
-  c: number;
-  m: number;
-  y: number;
-  k: number;
-}>;
-type OklabColor = LabColor;
-type OklchColor = LchColor;
-type PartialAlpha<O> = Omit<O, 'alpha'> & {
-  alpha?: number;
-};
-type ObjectColor = PartialAlpha<RgbColor> | PartialAlpha<HslColor> | PartialAlpha<HsvColor> | PartialAlpha<HwbColor> | PartialAlpha<XyzColor> | PartialAlpha<LabColor> | PartialAlpha<LchColor> | PartialAlpha<CmykColor> | PartialAlpha<OklabColor> | PartialAlpha<OklchColor>;
-type AnyColor = string | ObjectColor;
-type InputObject = Record<string, unknown>;
-type Format = 'name' | 'hex' | 'rgb' | 'lrgb' | 'hsl' | 'hsv' | 'hwb' | 'xyz' | 'lab' | 'lch' | 'cmyk' | 'oklab' | 'oklch';
-type Input = string | InputObject;
-interface InputSource {
-  format: Format;
-  input: Input;
-}
-type ParseFunction<I extends Input> = (input: I) => RgbColor | null;
-type Parser<I extends Input> = [ParseFunction<I>, Format];
-type Parsers = {
-  string: Array<Parser<string>>;
-  object: Array<Parser<InputObject>>;
-};
-//#endregion
+import { a as HsvColor, c as InputSource, i as HslColor, t as AnyColor, v as RgbColor } from "./types-B93dJkfp.js";
+
 //#region src/colord.d.ts
+
 /**
  * Parses the given input color and creates a new `Colord` instance.
  * See accepted input formats: https://github.com/omgovich/colord#color-parsing
@@ -174,4 +111,4 @@ declare class Colord {
   isEqual(color: AnyColor | Colord): boolean;
 }
 //#endregion
-export { Format as a, HwbColor as c, LchColor as d, OklabColor as f, XyzColor as g, RgbColor as h, CmykColor as i, Input as l, Parsers as m, colord as n, HslColor as o, OklchColor as p, AnyColor as r, HsvColor as s, Colord as t, LabColor as u };
+export { colord as n, Colord as t };

package/dist/colord.d.ts

@@ -1,2 +1,2 @@
-import { n as colord, t as Colord } from "./colord-Dc09uNcG.js";
+import { n as colord, t as Colord } from "./colord-DjohCNUk.js";
 export { Colord, colord };

package/dist/colord.js

@@ -1,10 +1,10 @@
-import "./utils-CshL9w1R.js";
-import "./rgb-BVkoWOmR.js";
-import { n as colord, t as Colord } from "./colord-CLzIbIN2.js";
-import "./hsv-OOAVcaRH.js";
-import "./manipulate-DCHNBCkU.js";
-import "./xyz-DsYRwYO_.js";
-import "./lab-9NsKpGel.js";
-import "./get-SLuYLSG9.js";
+import "./utils-BhDL0kto.js";
+import "./rgb-BIWjP3hJ.js";
+import { n as colord, t as Colord } from "./colord-CiL21DdP.js";
+import "./hsv-6f-Avk00.js";
+import "./manipulate-DJ-cBonL.js";
+import "./xyz-Czd8MTub.js";
+import "./lab-DklZwOkG.js";
+import "./get-DjkEJgax.js";
 
 export { Colord, colord };

package/dist/extend-Cjbo01n8.js

@@ -0,0 +1,15 @@
+import { a as parsers, t as Colord } from "./colord-CiL21DdP.js";
+
+//#region src/extend.ts
+const activePlugins = [];
+const extend = (plugins) => {
+	plugins.forEach((plugin) => {
+		if (!activePlugins.includes(plugin)) {
+			plugin(Colord, parsers);
+			activePlugins.push(plugin);
+		}
+	});
+};
+
+//#endregion
+export { extend as t };

package/dist/{extend-D_jQFvDk.d.ts → extend-DmcZT4-q.d.ts}

@@ -1,4 +1,5 @@
-import { m as Parsers, t as Colord } from "./colord-Dc09uNcG.js";
+import { _ as Parsers } from "./types-B93dJkfp.js";
+import { t as Colord } from "./colord-DjohCNUk.js";
 
 //#region src/extend.d.ts
 type Plugin = (ColordClass: typeof Colord, parsers: Parsers) => void;

package/dist/{get-SLuYLSG9.js → get-DjkEJgax.js}

@@ -1,4 +1,4 @@
-import { o as rgbToLinearRgb } from "./rgb-BVkoWOmR.js";
+import { o as rgbToLinearRgb } from "./rgb-BIWjP3hJ.js";
 
 //#region src/shared/get.ts
 /**

package/dist/{hsv-OOAVcaRH.js → hsv-6f-Avk00.js}

@@ -1,4 +1,4 @@
-import { i as isPresent, l as round, n as clampHue, t as clamp, v as ALPHA_PRECISION } from "./utils-CshL9w1R.js";
+import { i as isPresent, l as round, n as clampHue, t as clamp, v as ALPHA_PRECISION } from "./utils-BhDL0kto.js";
 
 //#region src/models/hsv.ts
 const clampHsv = (hsv) => ({

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { a as Format, c as HwbColor, d as LchColor, f as OklabColor, g as XyzColor, h as RgbColor, l as Input, n as colord, o as HslColor, p as OklchColor, r as AnyColor, s as HsvColor, t as Colord, u as LabColor } from "./colord-Dc09uNcG.js";
-import { n as extend, t as Plugin } from "./extend-D_jQFvDk.js";
+import { a as HsvColor, b as XyzColor, f as OklabColor, i as HslColor, l as LabColor, o as HwbColor, p as OklchColor, r as Format, s as Input, t as AnyColor, u as LchColor, v as RgbColor } from "./types-B93dJkfp.js";
+import { n as colord, t as Colord } from "./colord-DjohCNUk.js";
+import { n as extend, t as Plugin } from "./extend-DmcZT4-q.js";
 
 //#region src/shared/parse.d.ts
 

package/dist/index.js

@@ -1,22 +1,11 @@
-import "./utils-CshL9w1R.js";
-import "./rgb-BVkoWOmR.js";
-import { a as parsers, i as getFormat, n as colord, r as random, t as Colord } from "./colord-CLzIbIN2.js";
-import "./hsv-OOAVcaRH.js";
-import "./manipulate-DCHNBCkU.js";
-import "./xyz-DsYRwYO_.js";
-import "./lab-9NsKpGel.js";
-import "./get-SLuYLSG9.js";
+import "./utils-BhDL0kto.js";
+import "./rgb-BIWjP3hJ.js";
+import { i as getFormat, n as colord, r as random, t as Colord } from "./colord-CiL21DdP.js";
+import "./hsv-6f-Avk00.js";
+import "./manipulate-DJ-cBonL.js";
+import "./xyz-Czd8MTub.js";
+import "./lab-DklZwOkG.js";
+import "./get-DjkEJgax.js";
+import { t as extend } from "./extend-Cjbo01n8.js";
 
-//#region src/extend.ts
-const activePlugins = [];
-const extend = (plugins) => {
-	plugins.forEach((plugin) => {
-		if (!activePlugins.includes(plugin)) {
-			plugin(Colord, parsers);
-			activePlugins.push(plugin);
-		}
-	});
-};
-
-//#endregion
 export { Colord, colord, extend, getFormat, random };

package/dist/lab-BXLaTQvQ.js

@@ -0,0 +1,27 @@
+import { l as round, t as clamp } from "./utils-BhDL0kto.js";
+import { a as parseLabToRgb, c as roundLab, i as parseLabStringToRgb, l as toLabStringBySource, o as rgbToLab, r as parseLabBySource, s as rgbToLabString } from "./lab-DklZwOkG.js";
+import { r as getDeltaE2000 } from "./get-DjkEJgax.js";
+
+//#region src/plugins/lab.ts
+/**
+* A plugin adding support for CIELAB color space.
+* https://en.wikipedia.org/wiki/CIELAB_color_space
+*/
+const labPlugin = (ColordClass, parsers) => {
+	ColordClass.prototype.toLab = function toLab() {
+		return roundLab(parseLabBySource(this.getSource()) || rgbToLab(this.rgb));
+	};
+	ColordClass.prototype.toLabString = function toLabString() {
+		return toLabStringBySource(this.getSource()) || rgbToLabString(this.rgb);
+	};
+	ColordClass.prototype.delta = function delta(color = "#FFF") {
+		const compared = color instanceof ColordClass ? color : new ColordClass(color);
+		return clamp(round(getDeltaE2000(this.toLab(), compared.toLab()) / 100, 3));
+	};
+	parsers.string.push([parseLabStringToRgb, "lab"]);
+	parsers.object.push([parseLabToRgb, "lab"]);
+};
+var lab_default = labPlugin;
+
+//#endregion
+export { lab_default as n, labPlugin as t };

package/dist/{lab-9NsKpGel.js → lab-DklZwOkG.js}

@@ -1,6 +1,6 @@
-import { a as mul3x3, d as M_D65_TO_D50, i as isPresent, l as round, o as parseAlpha, t as clamp, u as M_D50_TO_D65, v as ALPHA_PRECISION, y as D50 } from "./utils-CshL9w1R.js";
-import { n as clampRgb } from "./rgb-BVkoWOmR.js";
-import { a as xyzToRgb, r as rgbToXyz } from "./xyz-DsYRwYO_.js";
+import { a as mul3x3, d as M_D65_TO_D50, i as isPresent, l as round, o as parseAlpha, t as clamp, u as M_D50_TO_D65, v as ALPHA_PRECISION, y as D50 } from "./utils-BhDL0kto.js";
+import { n as clampRgb } from "./rgb-BIWjP3hJ.js";
+import { a as xyzToRgb, r as rgbToXyz } from "./xyz-Czd8MTub.js";
 
 //#region src/models/lab.ts
 const EPSILON = 216 / 24389;

package/dist/{manipulate-DCHNBCkU.js → manipulate-DJ-cBonL.js}

@@ -1,6 +1,6 @@
-import { i as isPresent, l as round, n as clampHue, o as parseAlpha, s as parseHue, t as clamp, v as ALPHA_PRECISION } from "./utils-CshL9w1R.js";
-import { r as rgbToHsv, t as hsvToRgb } from "./hsv-OOAVcaRH.js";
-import { n as labToRgb, o as rgbToLab, t as clampLab } from "./lab-9NsKpGel.js";
+import { i as isPresent, l as round, n as clampHue, o as parseAlpha, s as parseHue, t as clamp, v as ALPHA_PRECISION } from "./utils-BhDL0kto.js";
+import { r as rgbToHsv, t as hsvToRgb } from "./hsv-6f-Avk00.js";
+import { n as labToRgb, o as rgbToLab, t as clampLab } from "./lab-DklZwOkG.js";
 
 //#region src/models/hsl.ts
 const clampHsl = (hsl) => {

package/dist/oklch-sYjVoJRG.js

@@ -0,0 +1,186 @@
+import { _ as OKLAB_M2_INV, a as mul3x3, c as parseValueToDecimal, g as OKLAB_M2, h as OKLAB_M1_INV, i as isPresent, l as round, m as OKLAB_M1, n as clampHue, o as parseAlpha, s as parseHue, t as clamp, v as ALPHA_PRECISION } from "./utils-BhDL0kto.js";
+import { n as clampRgb, o as rgbToLinearRgb, r as linearRgbToRgb, t as clampLinearRgb } from "./rgb-BIWjP3hJ.js";
+
+//#region src/models/oklch.ts
+const clampOklch = (oklch) => {
+	const { l, c, h, alpha } = oklch;
+	return {
+		l: clamp(l, 0, 1),
+		c: clamp(c, 0, .37),
+		h: clampHue(h),
+		alpha: clamp(alpha)
+	};
+};
+const roundOklch = (oklch) => {
+	const { l, c, h, alpha } = oklch;
+	return {
+		l: round(l, 3),
+		c: round(c, 3),
+		h: round(h, 3),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+/**
+* Convert OKLCH to Linear RGB without gamut mapping
+*/
+const oklchToLinearRgb = (oklch) => {
+	const { l, c, h, alpha } = oklch;
+	const hRad = h * Math.PI / 180;
+	const [r, g, b] = mul3x3(OKLAB_M1_INV, mul3x3(OKLAB_M2_INV, [
+		l,
+		c * Math.cos(hRad),
+		c * Math.sin(hRad)
+	]).map((v) => v * v * v));
+	return {
+		r,
+		g,
+		b,
+		alpha
+	};
+};
+/**
+* Check if a linear RGB color is within sRGB gamut
+*/
+const isInGamut = (linearRgb, epsilon = 1e-6) => {
+	return linearRgb.r >= -epsilon && linearRgb.r <= 1 + epsilon && linearRgb.g >= -epsilon && linearRgb.g <= 1 + epsilon && linearRgb.b >= -epsilon && linearRgb.b <= 1 + epsilon;
+};
+/**
+* Binary search to find maximum chroma that fits in sRGB gamut
+* @param l - Lightness (0-1)
+* @param h - Hue (0-360)
+* @param alpha - Alpha (0-1)
+* @returns Maximum chroma that fits in sRGB gamut
+*/
+const findGamutChroma = (l, h, alpha) => {
+	let min = 0;
+	let max = .37;
+	const epsilon = 1e-5;
+	if (isInGamut(oklchToLinearRgb({
+		l,
+		c: max,
+		h,
+		alpha
+	}), epsilon)) return max;
+	while (max - min > epsilon) {
+		const mid = (min + max) / 2;
+		if (isInGamut(oklchToLinearRgb({
+			l,
+			c: mid,
+			h,
+			alpha
+		}), epsilon)) min = mid;
+		else max = mid;
+	}
+	return min;
+};
+const oklchToRgb = (oklch) => {
+	const { l, h, alpha } = oklch;
+	let linearRgb = oklchToLinearRgb(oklch);
+	if (!isInGamut(linearRgb)) linearRgb = oklchToLinearRgb({
+		l,
+		c: findGamutChroma(l, h, alpha),
+		h,
+		alpha
+	});
+	linearRgb = clampLinearRgb(linearRgb);
+	return clampRgb(linearRgbToRgb(linearRgb));
+};
+const rgbToOklch = (rgb) => {
+	const lRgb = rgbToLinearRgb(rgb);
+	const [l, a, b] = mul3x3(OKLAB_M2, mul3x3(OKLAB_M1, [
+		lRgb.r,
+		lRgb.g,
+		lRgb.b
+	]).map((v) => Math.cbrt(v)));
+	const chroma = Math.sqrt(a * a + b * b);
+	let hue;
+	if (chroma < 1e-4) hue = 0;
+	else {
+		hue = Math.atan2(b, a) * (180 / Math.PI);
+		if (hue < 0) hue += 360;
+	}
+	return clampOklch({
+		l,
+		c: chroma,
+		h: hue,
+		alpha: rgb.alpha
+	});
+};
+const parseOklch = ({ l, c, h, alpha = 1 }) => {
+	if (!isPresent(l) || !isPresent(c) || !isPresent(h)) return null;
+	return clampOklch({
+		l: Number(l),
+		c: Number(c),
+		h: Number(h),
+		alpha: Number(alpha)
+	});
+};
+const parseOklchToRgb = (input) => {
+	const oklch = parseOklch(input);
+	if (!oklch) return null;
+	return oklchToRgb(oklch);
+};
+/**
+* Parsing syntax: oklch(L c h [/ alpha])
+* - L: <number|percentage>
+* - c: <number>
+* - h: <number>
+* - alpha: <number|percentage>
+*/
+const oklchMatcher = /^oklch\(\s*([+-]?[\d.]+)%?\s+([+-]?[\d.]+)\s+([+-]?[\d.]+)(deg|grad|rad|turn)?(?:\s*\/\s*([+-]?[\d.]+%?))?\s*\)$/i;
+const parseOklchString = (input) => {
+	const match = oklchMatcher.exec(input);
+	if (!match) return null;
+	const [_, l, c, h, unit, alpha] = match;
+	return clampOklch({
+		l: parseValueToDecimal(l),
+		c: Number.parseFloat(c),
+		h: parseHue(h, unit),
+		alpha: parseAlpha(alpha)
+	});
+};
+const parseOklchStringToRgb = (input) => {
+	const oklch = parseOklchString(input);
+	if (!oklch) return null;
+	return oklchToRgb(oklch);
+};
+const toOklchString = (oklch) => {
+	const { l, c, h, alpha } = roundOklch(oklch);
+	return alpha < 1 ? `oklch(${l} ${c} ${h} / ${alpha})` : `oklch(${l} ${c} ${h})`;
+};
+const rgbToOklchString = (rgb) => {
+	return toOklchString(rgbToOklch(rgb));
+};
+const parseOklchBySource = (source) => {
+	if (!source || source.format !== "oklch") return null;
+	const { input } = source;
+	if (typeof input === "string") return parseOklchString(input);
+	if (typeof input === "object") return parseOklch(input);
+	return null;
+};
+const toOklchStringBySource = (source) => {
+	const oklch = parseOklchBySource(source);
+	if (!oklch) return null;
+	return toOklchString(oklch);
+};
+
+//#endregion
+//#region src/plugins/oklch.ts
+/**
+* A plugin adding support for OKLCH colorspace.
+* https://bottosson.github.io/posts/oklab/
+*/
+const oklchPlugin = (ColordClass, parsers) => {
+	ColordClass.prototype.toOklch = function toOklch() {
+		return roundOklch(parseOklchBySource(this.getSource()) || rgbToOklch(this.rgb));
+	};
+	ColordClass.prototype.toOklchString = function toOklchString$1() {
+		return toOklchStringBySource(this.getSource()) || rgbToOklchString(this.rgb);
+	};
+	parsers.string.push([parseOklchStringToRgb, "oklch"]);
+	parsers.object.push([parseOklchToRgb, "oklch"]);
+};
+var oklch_default = oklchPlugin;
+
+//#endregion
+export { oklch_default as n, oklchPlugin as t };

package/dist/palette/index.d.ts

@@ -0,0 +1,30 @@
+import { d as NearestPalette, g as PaletteColorLevel, h as OutputFormat, m as OutputColorMap, t as AnyColor, y as TailwindPaletteColor } from "../types-B93dJkfp.js";
+
+//#region src/palette/constant.d.ts
+
+/**
+ * TailwindCSS v4 official oklch palette data
+ *
+ * the format is `oklch` string
+ */
+declare const tailwindPalette: TailwindPaletteColor;
+//#endregion
+//#region src/palette/generate.d.ts
+/**
+ * generate the palette
+ * @param input - the base color
+ * @param [format] - the format of the output color, default is 'oklch'
+ * @returns the palette
+ */
+declare function generatePalette<F extends OutputFormat>(input: AnyColor, format?: F): Record<PaletteColorLevel, OutputColorMap[F]>;
+//#endregion
+//#region src/palette/nearest.d.ts
+/**
+ * find the nearest palette color
+ * @param input - the input color
+ * @param format - the format of the output color
+ * @returns the nearest palette color
+ */
+declare function generateNearestPalette<F extends OutputFormat>(input: AnyColor, format?: F): NearestPalette<F>;
+//#endregion
+export { generateNearestPalette, generatePalette, tailwindPalette };