@soybeanjs/colord 0.0.1

package/dist/plugins/oklch.js

@@ -0,0 +1,112 @@
+import { _ as ALPHA_PRECISION, a as mul3x3, c as round, g as OKLAB_M2_INV, h as OKLAB_M2, i as isPresent, m as OKLAB_M1_INV, n as clampHue, o as parseAlpha, p as OKLAB_M1, s as parseHue, t as clamp } from "../utils-BgIyY6bK.js";
+import { n as clampRgb, o as rgbToLinearRgb, r as linearRgbToRgb, t as clampLinearRgb } from "../rgb-CfVJB1Bj.js";
+
+//#region src/models/oklch.ts
+const clampOklch = (oklch) => {
+	const { l, c, h, alpha } = oklch;
+	return {
+		l: clamp(l, 1e-4, 1),
+		c: clamp(c, 1e-4, .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)
+	};
+};
+const oklchToRgb = (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 clampRgb(linearRgbToRgb(clampLinearRgb({
+		r,
+		g,
+		b,
+		alpha
+	})));
+};
+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 oklchToRgb(clampOklch({
+		l: Number(l),
+		c: Number(c),
+		h: Number(h),
+		alpha: Number(alpha)
+	}));
+};
+/**
+* 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;
+/**
+* Parses a valid OKLCH CSS color function/string
+* https://www.w3.org/TR/css-color-4/#specifying-oklch
+* @param input
+* @returns
+*/
+const parseOklchString = (input) => {
+	const match = oklchMatcher.exec(input);
+	if (!match) return null;
+	const [_, L, c, h, unit, alpha] = match;
+	let l = Number.parseFloat(L);
+	if (L.endsWith("%")) l /= 100;
+	return oklchToRgb(clampOklch({
+		l,
+		c: Number.parseFloat(c),
+		h: parseHue(h, unit),
+		alpha: parseAlpha(alpha)
+	}));
+};
+
+//#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(rgbToOklch(this.rgb));
+	};
+	parsers.string.push([parseOklchString, "oklch"]);
+	parsers.object.push([parseOklch, "oklch"]);
+};
+var oklch_default = oklchPlugin;
+
+//#endregion
+export { oklch_default as default, oklchPlugin };

package/dist/plugins/xyz.d.ts

@@ -0,0 +1,17 @@
+import { g as XyzColor } from "../colord-xpgrVWRV.js";
+import { t as Plugin } from "../extend-DrPfn2Q1.js";
+
+//#region src/plugins/xyz.d.ts
+declare module '../colord' {
+  interface Colord {
+    toXyz(): XyzColor;
+  }
+}
+/**
+ * A plugin adding support for CIE XYZ colorspace.
+ * Wikipedia: https://en.wikipedia.org/wiki/CIE_1931_color_space
+ * Helpful article: https://www.sttmedia.com/colormodel-xyz
+ */
+declare const xyzPlugin: Plugin;
+//#endregion
+export { xyzPlugin as default, xyzPlugin };

package/dist/plugins/xyz.js

@@ -0,0 +1,20 @@
+import "../utils-BgIyY6bK.js";
+import "../rgb-CfVJB1Bj.js";
+import { n as rgbToXyz, r as roundXyz, t as parseXyz } from "../xyz-MII3ndWO.js";
+
+//#region src/plugins/xyz.ts
+/**
+* A plugin adding support for CIE XYZ colorspace.
+* Wikipedia: https://en.wikipedia.org/wiki/CIE_1931_color_space
+* Helpful article: https://www.sttmedia.com/colormodel-xyz
+*/
+const xyzPlugin = (ColordClass, parsers) => {
+	ColordClass.prototype.toXyz = function toXyz() {
+		return roundXyz(rgbToXyz(this.rgb));
+	};
+	parsers.object.push([parseXyz, "xyz"]);
+};
+var xyz_default = xyzPlugin;
+
+//#endregion
+export { xyz_default as default, xyzPlugin };

package/dist/rgb-CfVJB1Bj.js

@@ -0,0 +1,148 @@
+import { _ as ALPHA_PRECISION, c as round, i as isPresent, o as parseAlpha, t as clamp } from "./utils-BgIyY6bK.js";
+
+//#region src/models/rgb.ts
+const clampRgb = (rgb) => {
+	const { r, g, b, alpha } = rgb;
+	return {
+		r: clamp(r, 0, 255),
+		g: clamp(g, 0, 255),
+		b: clamp(b, 0, 255),
+		alpha: clamp(alpha)
+	};
+};
+const roundRgb = (rgb) => {
+	const { r, g, b, alpha } = rgb;
+	return {
+		r: round(r),
+		g: round(g),
+		b: round(b),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+const clampLinearRgb = (rgb) => {
+	const { r, g, b, alpha } = rgb;
+	return {
+		r: clamp(r, 1e-4, 1),
+		g: clamp(g, 1e-4, 1),
+		b: clamp(b, 1e-4, 1),
+		alpha: clamp(alpha)
+	};
+};
+const parseRgb = ({ r, g, b, alpha = 1 }) => {
+	if (!isPresent(r) || !isPresent(g) || !isPresent(b)) return null;
+	return clampRgb({
+		r: Number(r),
+		g: Number(g),
+		b: Number(b),
+		alpha: Number(alpha)
+	});
+};
+/**
+* Converts a single sRGB component value to linear light.
+* This applies gamma expansion (inverse of sRGB transfer function).
+*
+* The sRGB transfer function has two parts:
+* - Linear segment for very dark values (≤ 0.04045)
+* - Power curve with gamma ≈ 2.4 for brighter values
+*
+* @param value - sRGB component value (0-255)
+*/
+const rgbToLinear = (value) => {
+	const v = value / 255;
+	if (v <= .04045) return v / 12.92;
+	return ((v + .055) / 1.055) ** 2.4;
+};
+/**
+* Converts a linear light value to sRGB component.
+* This applies gamma compression (sRGB transfer function).
+*
+* The sRGB transfer function has two parts:
+* - Linear segment for very dark values (≤ 0.0031308)
+* - Power curve with gamma ≈ 1/2.4 for brighter values
+*
+* @param value - Linear light value (0-1)
+*/
+function linearToRgb(value) {
+	const v = value <= .0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - .055;
+	return Math.round(v * 255);
+}
+/**
+* Converts an RGBA color to Linear RGB color space.
+*
+* This applies gamma expansion to each RGB component,
+* converting from perceptually uniform sRGB to physically
+* linear light values. Alpha channel is passed through unchanged.
+*
+* @param rgb - The RGBA color to convert (r, g, b: 0-255, a: 0-1)
+*/
+function rgbToLinearRgb(rgb) {
+	return {
+		r: rgbToLinear(rgb.r),
+		g: rgbToLinear(rgb.g),
+		b: rgbToLinear(rgb.b),
+		alpha: rgb.alpha
+	};
+}
+/**
+* Converts a Linear RGB color to RGBA color space.
+*
+* This applies gamma compression to each RGB component,
+* converting from physically linear light values to
+* perceptually uniform sRGB. Alpha channel is passed through unchanged.
+*
+* @param rgb - The LinearRGB color to convert (r, g, b: 0-1 linear, a: 0-1)
+* @returns RGBA color (r, g, b: 0-255, a: 0-1)
+*
+* @example
+* ```typescript
+* // Pure red
+* linearRgbToRgb({ r: 1, g: 0, b: 0, a: 1 });
+* // { r: 255, g: 0, b: 0, a: 1 }
+*
+* // Linear mid-point is NOT perceptual mid-gray
+* linearRgbToRgb({ r: 0.5, g: 0.5, b: 0.5, a: 1 });
+* // { r: 188, g: 188, b: 188, a: 1 } - looks quite bright!
+*
+* // With transparency
+* linearRgbToRgb({ r: 1, g: 0.216, b: 0, a: 0.5 });
+* // { r: 255, g: 128, b: 0, a: 0.5 }
+* ```
+*/
+function linearRgbToRgb(rgb) {
+	return {
+		r: linearToRgb(rgb.r),
+		g: linearToRgb(rgb.g),
+		b: linearToRgb(rgb.b),
+		alpha: rgb.alpha
+	};
+}
+const rgbMatcher = /^rgb?\(\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)(?:\s*[,/]\s*([\d.]+%?))?\s*\)$/i;
+/**
+* Parses a valid RGB[A] CSS color function/string
+* https://www.w3.org/TR/css-color-4/#rgb-functions
+*/
+const parseRgbString = (input) => {
+	const match = rgbMatcher.exec(input);
+	if (!match) return null;
+	const [_, r, g, b, alpha] = match;
+	return clampRgb({
+		r: parseValue(r),
+		g: parseValue(g),
+		b: parseValue(b),
+		alpha: parseAlpha(alpha)
+	});
+};
+function parseValue(str) {
+	if (str.endsWith("%")) {
+		const percent = Number.parseFloat(str.slice(0, -1));
+		return Math.round(percent / 100 * 255);
+	}
+	return Number.parseFloat(str);
+}
+const rgbToRgbString = (rgb) => {
+	const { r, g, b, alpha } = roundRgb(rgb);
+	return alpha < 1 ? `rgb(${r}, ${g}, ${b}, ${alpha})` : `rgb(${r}, ${g}, ${b})`;
+};
+
+//#endregion
+export { parseRgbString as a, roundRgb as c, parseRgb as i, clampRgb as n, rgbToLinearRgb as o, linearRgbToRgb as r, rgbToRgbString as s, clampLinearRgb as t };

package/dist/utils-BgIyY6bK.js

@@ -0,0 +1,229 @@
+//#region src/constants/common.ts
+/**
+* We used to work with 2 digits after the decimal point, but it wasn't accurate enough,
+* so the library produced colors that were perceived differently.
+*/
+const ALPHA_PRECISION = 3;
+/**
+* Valid CSS <angle> units.
+* https://developer.mozilla.org/en-US/docs/Web/CSS/angle
+*/
+const ANGLE_UNITS = {
+	grad: 360 / 400,
+	turn: 360,
+	rad: 360 / (Math.PI * 2)
+};
+const D50 = {
+	x: .96422,
+	y: 1,
+	z: .82521
+};
+
+//#endregion
+//#region src/constants/matrix.ts
+const OKLAB_M1 = [
+	[
+		.4122214708,
+		.5363325363,
+		.0514459929
+	],
+	[
+		.2119034982,
+		.6806995451,
+		.1073969566
+	],
+	[
+		.0883024619,
+		.2817188376,
+		.6299787005
+	]
+];
+const OKLAB_M1_INV = [
+	[
+		4.076741661347993,
+		-3.3077115904081937,
+		.2309699287294278
+	],
+	[
+		-1.2684380040921763,
+		2.609757400663372,
+		-.3413193963102196
+	],
+	[
+		-.0041960865418371,
+		-.7034186144594495,
+		1.7076147009309446
+	]
+];
+const OKLAB_M2 = [
+	[
+		.2104542553,
+		.793617785,
+		-.0040720468
+	],
+	[
+		1.9779984951,
+		-2.428592205,
+		.4505937099
+	],
+	[
+		.0259040371,
+		.7827717662,
+		-.808675766
+	]
+];
+const OKLAB_M2_INV = [
+	[
+		.9999999984505198,
+		.3963377921737678,
+		.2158037580607588
+	],
+	[
+		1.0000000088817607,
+		-.1055613423236563,
+		-.0638541747717059
+	],
+	[
+		1.0000000546724108,
+		-.0894841820949657,
+		-1.2914855378640917
+	]
+];
+const M_SRGB_TO_XYZ_D65 = [
+	[
+		.4124564391,
+		.3575760776,
+		.1804374833
+	],
+	[
+		.2126728514,
+		.7151521552,
+		.0721749934
+	],
+	[
+		.0193338956,
+		.1191920259,
+		.9503040785
+	]
+];
+const M_XYZ_D65_TO_SRGB = [
+	[
+		3.2404541621,
+		-1.5371385127,
+		-.4985314095
+	],
+	[
+		-.9692660305,
+		1.8760108454,
+		.0415560175
+	],
+	[
+		.055643431,
+		-.2040259135,
+		1.0572251882
+	]
+];
+const M_D65_TO_D50 = [
+	[
+		1.0478112,
+		.0228866,
+		-.050127
+	],
+	[
+		.0295424,
+		.9904844,
+		-.0170491
+	],
+	[
+		-.0092345,
+		.0150436,
+		.7521316
+	]
+];
+const M_D50_TO_D65 = [
+	[
+		.9555766,
+		-.0230393,
+		.0631636
+	],
+	[
+		-.0282895,
+		1.0099416,
+		.0210077
+	],
+	[
+		.0122982,
+		-.020483,
+		1.3299098
+	]
+];
+
+//#endregion
+//#region src/utils/index.ts
+const isPresent = (value) => {
+	if (typeof value === "string") return value.length > 0;
+	if (typeof value === "number") return true;
+	return false;
+};
+/**
+* Rounds a number to the specified number of decimal places.
+* @param number - The number to round
+* @param digits - The number of decimal places (default: 0)
+* @returns The rounded number (converts -0 to 0)
+*/
+const round = (number, digits = 0) => {
+	const base = 10 ** digits;
+	return Math.round(base * number) / base + 0;
+};
+/**
+* Floors a number to the specified number of decimal places.
+* @param number - The number to floor
+* @param digits - The number of decimal places (default: 0)
+* @returns The floored number (converts -0 to 0)
+*/
+const floor = (number, digits = 0) => {
+	const base = 10 ** digits;
+	return Math.floor(base * number) / base + 0;
+};
+/**
+* Clamps a value between an upper and lower bound.
+* We use ternary operators because it makes the minified code
+* is 2 times shorter then `Math.min(Math.max(a,b),c)`
+* NaN is clamped to the lower bound
+*/
+const clamp = (number, min = 0, max = 1) => {
+	if (number > max) return max;
+	if (number < min) return min;
+	return number;
+};
+/**
+* Processes and clamps a degree (angle) value properly.
+* Any `NaN` or `Infinity` will be converted to `0`.
+* Examples: -1 => 359, 361 => 1
+*/
+const clampHue = (degrees) => {
+	const degree = Number.isFinite(degrees) ? degrees % 360 : 0;
+	return degree > 0 ? degree : degree + 360;
+};
+/**
+* Converts a hue value to degrees from 0 to 360 inclusive.
+*/
+const parseHue = (value, unit = "deg") => {
+	return Number.parseFloat(value) * (ANGLE_UNITS[unit] || 1);
+};
+function mul3x3(m, v) {
+	return [
+		m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
+		m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
+		m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2]
+	];
+}
+function parseAlpha(alpha) {
+	if (!alpha) return 1;
+	let value = Number.parseFloat(alpha);
+	if (alpha.endsWith("%")) value /= 100;
+	return value;
+}
+
+//#endregion
+export { ALPHA_PRECISION as _, mul3x3 as a, round as c, M_SRGB_TO_XYZ_D65 as d, M_XYZ_D65_TO_SRGB as f, OKLAB_M2_INV as g, OKLAB_M2 as h, isPresent as i, M_D50_TO_D65 as l, OKLAB_M1_INV as m, clampHue as n, parseAlpha as o, OKLAB_M1 as p, floor as r, parseHue as s, clamp as t, M_D65_TO_D50 as u, D50 as v };

package/dist/xyz-MII3ndWO.js

@@ -0,0 +1,73 @@
+import { _ as ALPHA_PRECISION, a as mul3x3, c as round, d as M_SRGB_TO_XYZ_D65, f as M_XYZ_D65_TO_SRGB, i as isPresent, t as clamp, v as D50 } from "./utils-BgIyY6bK.js";
+import { n as clampRgb, o as rgbToLinearRgb, r as linearRgbToRgb } from "./rgb-CfVJB1Bj.js";
+
+//#region src/models/xyz.ts
+/**
+* Limits XYZ axis values assuming XYZ is relative to D50.
+*/
+const clampXyz = (xyz) => {
+	const { x, y, z, alpha } = xyz;
+	return {
+		x: clamp(x, 1e-4, D50.x),
+		y: clamp(y, 1e-4, D50.y),
+		z: clamp(z, 1e-4, D50.z),
+		alpha: clamp(alpha)
+	};
+};
+const roundXyz = (xyz) => {
+	const { x, y, z, alpha } = xyz;
+	return {
+		x: round(x, 4),
+		y: round(y, 4),
+		z: round(z, 4),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+/**
+* Converts an CIE XYZ color (D50) to RGBA color space (D65)
+* https://www.w3.org/TR/css-color-4/#color-conversion-code
+*/
+const xyzToRgb = (xyz) => {
+	const { x, y, z, alpha } = xyz;
+	const [r, g, b] = mul3x3(M_XYZ_D65_TO_SRGB, [
+		x,
+		y,
+		z
+	]);
+	return clampRgb(linearRgbToRgb({
+		r,
+		g,
+		b,
+		alpha
+	}));
+};
+/**
+* Converts an RGB color (D65) to CIE XYZ (D50)
+* https://image-engineering.de/library/technotes/958-how-to-convert-between-srgb-and-ciexyz
+*/
+const rgbToXyz = (rgb) => {
+	const { r, g, b, alpha } = rgbToLinearRgb(rgb);
+	const [x, y, z] = mul3x3(M_SRGB_TO_XYZ_D65, [
+		r,
+		g,
+		b
+	]);
+	return clampXyz({
+		x,
+		y,
+		z,
+		alpha
+	});
+};
+const parseXyz = ({ x, y, z, alpha = 1 }) => {
+	if (!isPresent(x) || !isPresent(y) || !isPresent(z)) return null;
+	return xyzToRgb(clampXyz({
+		x: Number(x),
+		y: Number(y),
+		z: Number(z),
+		alpha: Number(alpha)
+	}));
+};
+
+//#endregion
+export { xyzToRgb as i, rgbToXyz as n, roundXyz as r, parseXyz as t };

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@soybeanjs/colord",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "A tiny yet powerful tool for high-performance color manipulations and conversions",
+  "author": {
+    "name": "Soybean",
+    "email": "soybeanjs@outlook.com",
+    "url": "https://github.com/soybeanjs"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/soybeanjs/colord",
+  "repository": {
+    "url": "https://github.com/soybeanjs/colord.git"
+  },
+  "bugs": {
+    "url": "https://github.com/soybeanjs/colord/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./plugins/*": {
+      "types": "./dist/plugins/*.d.ts",
+      "import": "./dist/plugins/*.js",
+      "require": "./dist/plugins/*.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "cli-progress": "3.12.0",
+    "consola": "3.4.2",
+    "dayjs": "1.11.19",
+    "execa": "9.6.1",
+    "kolorist": "1.8.0",
+    "ofetch": "1.5.1"
+  },
+  "devDependencies": {
+    "@soybeanjs/cli": "1.4.4",
+    "@soybeanjs/eslint-config": "1.7.5",
+    "@types/cli-progress": "3.11.6",
+    "@types/node": "25.0.8",
+    "@types/tinycolor2": "^1.4.6",
+    "colord": "^2.9.3",
+    "eslint": "9.39.2",
+    "lint-staged": "16.2.7",
+    "simple-git-hooks": "2.13.1",
+    "tinycolor2": "^1.6.0",
+    "tsdown": "0.19.0",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3"
+  },
+  "simple-git-hooks": {
+    "commit-msg": "pnpm soy git-commit-verify",
+    "pre-commit": "pnpm typecheck && pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "cleanup": "soy cleanup",
+    "commit": "soy git-commit",
+    "dev": "tsup --watch",
+    "lint": "eslint . --fix",
+    "publish-pkg": "pnpm publish --access public",
+    "release": "soy release",
+    "typecheck": "tsc --noEmit --skipLibCheck",
+    "update-pkg": "soy ncu"
+  }
+}