@soybeanjs/colord 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# @soybeanjs/colord
+
+  <strong>Colord</strong> is a tiny yet powerful tool for high-performance color manipulations and conversions. fork from [colord](https://github.com/omgovich/colord)
+
+## Features
+
+- 📦 **Small**: Just **1.7 KB** gzipped ([3x+ lighter](#benchmarks) than **color** and **tinycolor2**)
+- 🚀 **Fast**: [3x+ faster](#benchmarks) than **color** and **tinycolor2**
+- 😍 **Simple**: Chainable API and familiar patterns
+- 💪 **Immutable**: No need to worry about data mutations
+- 🛡 **Bulletproof**: Written in strict TypeScript and has 100% test coverage
+- 🗂 **Typed**: Ships with [types included](#types)
+- 🏗 **Extendable**: Built-in [plugin system](#plugins) to add new functionality
+- 📚 **CSS-compliant**: Strictly follows CSS Color Level specifications
+- 👫 **Works everywhere**: Supports all browsers and Node.js
+- 💨 **Dependency-free**
+
+## Differences from [colord](https://github.com/omgovich/colord)
+
+- support `oklab` and `oklch` color space
+- more correct color parsing
+- simplify type definitions
+- rewrite color string parsing
+- rename alpha property `a` to `alpha`
+
+## Getting Started
+
+```bash
+pnpm i @soybeanjs/colord
+```
+
+```ts
+import { colord } from '@soybeanjs/colord';
+
+colord("#ff0000").grayscale().alpha(0.25).toRgbString(); // "rgba(128, 128, 128, 0.25)"
+colord("rgb(192, 192, 192)").isLight(); // true
+colord("hsl(0, 50%, 50%)").darken(0.25).toHex(); // "#602020"
+colord({ r: 128, g: 128, b: 128, alpha: 0.25 }).toRgbString(); // "rgba(128, 128, 128, 0.25)"
+```
+
+## Supported Color Models
+
+- Hexadecimal strings (including 3, 4 and 8 digit notations)
+- RGB strings and objects
+- HSL strings and objects
+- HSV objects
+- Color names ([via plugin](#plugins))
+- HWB objects and strings ([via plugin](#plugins))
+- CMYK objects and strings ([via plugin](#plugins))
+- LCH objects and strings ([via plugin](#plugins))
+- LAB objects ([via plugin](#plugins))
+- XYZ objects ([via plugin](#plugins))
+- OKLAB objects ([via plugin](#plugins))
+- OKLCH objects ([via plugin](#plugins))
+
+## More API
+
+see the more api in [colord](https://github.com/omgovich/colord)

package/dist/colord-BV1k1-gC.js

@@ -0,0 +1,239 @@
+import { _ as ALPHA_PRECISION, c as round } from "./utils-BgIyY6bK.js";
+import { a as parseRgbString, c as roundRgb, i as parseRgb, s as rgbToRgbString } from "./rgb-CfVJB1Bj.js";
+import { i as roundHsv, n as parseHsv, r as rgbToHsv } from "./hsv-UWMaaOSN.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-CeAgrUd6.js";
+import { t as getBrightness } from "./get-BFaklfVd.js";
+
+//#region src/models/hex.ts
+const hexMatcher = /^#([0-9a-f]{3,8})$/i;
+/** Parses any valid Hex3, Hex4, Hex6 or Hex8 string and converts it to an RGBA object */
+const parseHex = (hexStr) => {
+	const hexMatch = hexMatcher.exec(hexStr);
+	if (!hexMatch) return null;
+	const hex = hexMatch[1];
+	if (hex.length <= 4) return {
+		r: Number.parseInt(hex[0] + hex[0], 16),
+		g: Number.parseInt(hex[1] + hex[1], 16),
+		b: Number.parseInt(hex[2] + hex[2], 16),
+		alpha: hex.length === 4 ? round(Number.parseInt(hex[3] + hex[3], 16) / 255, 2) : 1
+	};
+	if (hex.length === 6 || hex.length === 8) return {
+		r: Number.parseInt(hex.slice(0, 2), 16),
+		g: Number.parseInt(hex.slice(2, 4), 16),
+		b: Number.parseInt(hex.slice(4, 6), 16),
+		alpha: hex.length === 8 ? round(Number.parseInt(hex.slice(6, 8), 16) / 255, 2) : 1
+	};
+	return null;
+};
+/** Formats any decimal number (e.g. 128) as a hexadecimal string (e.g. "08") */
+const format = (number) => {
+	const hex = number.toString(16);
+	return hex.length < 2 ? `0${hex}` : hex;
+};
+/** Converts RGBA object to Hex6 or (if it has alpha channel) Hex8 string */
+const rgbToHex = (rgb) => {
+	const { r, g, b, alpha } = roundRgb(rgb);
+	const alphaHex = alpha < 1 ? format(round(alpha * 255)) : "";
+	return `#${format(r)}${format(g)}${format(b)}${alphaHex}`;
+};
+
+//#endregion
+//#region src/shared/parse.ts
+const parsers = {
+	string: [
+		[parseHex, "hex"],
+		[parseRgbString, "rgb"],
+		[parseHslString, "hsl"]
+	],
+	object: [
+		[parseRgb, "rgb"],
+		[parseHsl, "hsl"],
+		[parseHsv, "hsv"]
+	]
+};
+const findValidColor = (input, $parsers) => {
+	for (let i = 0; i < $parsers.length; i += 1) {
+		const result = $parsers[i][0](input);
+		if (result) return [result, $parsers[i][1]];
+	}
+	return [null, void 0];
+};
+/** Tries to convert an incoming value into RGBA color by going through all color model parsers */
+const parse = (input) => {
+	if (typeof input === "string") return findValidColor(input.trim(), parsers.string);
+	if (typeof input === "object" && input !== null) return findValidColor(input, parsers.object);
+	return [null, void 0];
+};
+/**
+* Returns a color model name for the input passed to the function.
+*/
+const getFormat = (input) => parse(input)[1];
+
+//#endregion
+//#region src/shared/random.ts
+const random = () => {
+	return new Colord({
+		r: Math.random() * 255,
+		g: Math.random() * 255,
+		b: Math.random() * 255
+	});
+};
+
+//#endregion
+//#region src/colord.ts
+/**
+* Parses the given input color and creates a new `Colord` instance.
+* See accepted input formats: https://github.com/omgovich/colord#color-parsing
+*/
+const colord = (input) => {
+	if (input instanceof Colord) return input;
+	return new Colord(input);
+};
+var Colord = class {
+	parsed;
+	rgb;
+	constructor(input) {
+		this.parsed = parse(input)[0];
+		this.rgb = this.parsed || {
+			r: 0,
+			g: 0,
+			b: 0,
+			alpha: 1
+		};
+	}
+	/**
+	* Returns a boolean indicating whether or not an input has been parsed successfully.
+	* Note: If parsing is unsuccessful, Colord defaults to black (does not throws an error).
+	*/
+	isValid() {
+		return this.parsed !== null;
+	}
+	/**
+	* Returns the brightness of a color (from 0 to 1).
+	* The calculation logic is modified from WCAG.
+	* https://www.w3.org/TR/AERT/#color-contrast
+	*/
+	brightness() {
+		return round(getBrightness(this.rgb), 2);
+	}
+	/**
+	* Same as calling `brightness() < 0.5`.
+	*/
+	isDark() {
+		return getBrightness(this.rgb) < .5;
+	}
+	/**
+	* Same as calling `brightness() >= 0.5`.
+	* */
+	isLight() {
+		return getBrightness(this.rgb) >= .5;
+	}
+	/**
+	* Returns the hexadecimal representation of a color.
+	* When the alpha channel value of the color is less than 1,
+	* it outputs #rrggbbaa format instead of #rrggbb.
+	*/
+	toHex() {
+		return rgbToHex(this.rgb);
+	}
+	/**
+	* Converts a color to RGB color space and returns an object.
+	* Always includes an alpha value from 0 to 1.
+	*/
+	toRgb() {
+		return roundRgb(this.rgb);
+	}
+	/**
+	* Converts a color to RGB color space and returns a string representation.
+	* Outputs an alpha value only if it is less than 1.
+	*/
+	toRgbString() {
+		return rgbToRgbString(this.rgb);
+	}
+	/**
+	* Converts a color to HSL color space and returns an object.
+	* Always includes an alpha value from 0 to 1.
+	*/
+	toHsl() {
+		return roundHsl(rgbToHsl(this.rgb));
+	}
+	/**
+	* Converts a color to HSL color space and returns a string representation.
+	* Always includes an alpha value from 0 to 1.
+	*/
+	toHslString() {
+		return rgbToHslString(this.rgb);
+	}
+	/**
+	* Converts a color to HSV color space and returns an object.
+	* Always includes an alpha value from 0 to 1.
+	*/
+	toHsv() {
+		return roundHsv(rgbToHsv(this.rgb));
+	}
+	/**
+	* Creates a new instance containing an inverted (opposite) version of the color.
+	*/
+	invert() {
+		return colord(invert(this.rgb));
+	}
+	/**
+	* Increases the HSL saturation of a color by the given amount.
+	*/
+	saturate(amount = .1) {
+		return colord(saturate(this.rgb, amount));
+	}
+	/**
+	* Decreases the HSL saturation of a color by the given amount.
+	*/
+	desaturate(amount = .1) {
+		return colord(saturate(this.rgb, -amount));
+	}
+	/**
+	* Makes a gray color with the same lightness as a source color.
+	*/
+	grayscale() {
+		return colord(saturate(this.rgb, -1));
+	}
+	/**
+	* Increases the HSL lightness of a color by the given amount.
+	*/
+	lighten(amount = .1) {
+		return colord(lighten(this.rgb, amount));
+	}
+	/**
+	* Increases the HSL lightness of a color by the given amount.
+	*/
+	darken(amount = .1) {
+		return colord(lighten(this.rgb, -amount));
+	}
+	/**
+	* Changes the HSL hue of a color by the given amount.
+	*/
+	rotate(amount = 15) {
+		return this.hue(this.hue() + amount);
+	}
+	alpha(value) {
+		if (typeof value === "number") return colord(changeAlpha(this.rgb, value));
+		return round(this.rgb.alpha, ALPHA_PRECISION);
+	}
+	hue(value) {
+		const hsl = rgbToHsl(this.rgb);
+		if (typeof value === "number") return colord({
+			h: value,
+			s: hsl.s,
+			l: hsl.l,
+			alpha: hsl.alpha
+		});
+		return round(hsl.h);
+	}
+	/**
+	* Determines whether two values are the same color.
+	*/
+	isEqual(color) {
+		return this.toHex() === colord(color).toHex();
+	}
+};
+
+//#endregion
+export { parsers as a, getFormat as i, colord as n, random as r, Colord as t };

package/dist/colord-xpgrVWRV.d.ts

@@ -0,0 +1,167 @@
+//#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;
+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
+//#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
+ */
+declare const colord: (input: AnyColor | Colord) => Colord;
+declare class Colord {
+  private readonly parsed;
+  readonly rgb: RgbColor;
+  constructor(input: AnyColor);
+  /**
+   * Returns a boolean indicating whether or not an input has been parsed successfully.
+   * Note: If parsing is unsuccessful, Colord defaults to black (does not throws an error).
+   */
+  isValid(): boolean;
+  /**
+   * Returns the brightness of a color (from 0 to 1).
+   * The calculation logic is modified from WCAG.
+   * https://www.w3.org/TR/AERT/#color-contrast
+   */
+  brightness(): number;
+  /**
+   * Same as calling `brightness() < 0.5`.
+   */
+  isDark(): boolean;
+  /**
+   * Same as calling `brightness() >= 0.5`.
+   * */
+  isLight(): boolean;
+  /**
+   * Returns the hexadecimal representation of a color.
+   * When the alpha channel value of the color is less than 1,
+   * it outputs #rrggbbaa format instead of #rrggbb.
+   */
+  toHex(): string;
+  /**
+   * Converts a color to RGB color space and returns an object.
+   * Always includes an alpha value from 0 to 1.
+   */
+  toRgb(): RgbColor;
+  /**
+   * Converts a color to RGB color space and returns a string representation.
+   * Outputs an alpha value only if it is less than 1.
+   */
+  toRgbString(): string;
+  /**
+   * Converts a color to HSL color space and returns an object.
+   * Always includes an alpha value from 0 to 1.
+   */
+  toHsl(): HslColor;
+  /**
+   * Converts a color to HSL color space and returns a string representation.
+   * Always includes an alpha value from 0 to 1.
+   */
+  toHslString(): string;
+  /**
+   * Converts a color to HSV color space and returns an object.
+   * Always includes an alpha value from 0 to 1.
+   */
+  toHsv(): HsvColor;
+  /**
+   * Creates a new instance containing an inverted (opposite) version of the color.
+   */
+  invert(): Colord;
+  /**
+   * Increases the HSL saturation of a color by the given amount.
+   */
+  saturate(amount?: number): Colord;
+  /**
+   * Decreases the HSL saturation of a color by the given amount.
+   */
+  desaturate(amount?: number): Colord;
+  /**
+   * Makes a gray color with the same lightness as a source color.
+   */
+  grayscale(): Colord;
+  /**
+   * Increases the HSL lightness of a color by the given amount.
+   */
+  lighten(amount?: number): Colord;
+  /**
+   * Increases the HSL lightness of a color by the given amount.
+   */
+  darken(amount?: number): Colord;
+  /**
+   * Changes the HSL hue of a color by the given amount.
+   */
+  rotate(amount?: number): Colord;
+  /**
+   * Allows to get or change an alpha channel value.
+   */
+  alpha(): number;
+  alpha(value: number): Colord;
+  /**
+   * Allows to get or change a hue value.
+   */
+  hue(): number;
+  hue(value: number): Colord;
+  /**
+   * Determines whether two values are the same color.
+   */
+  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 };

package/dist/colord.d.ts

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

package/dist/colord.js

@@ -0,0 +1,10 @@
+import "./utils-BgIyY6bK.js";
+import "./rgb-CfVJB1Bj.js";
+import { n as colord, t as Colord } from "./colord-BV1k1-gC.js";
+import "./hsv-UWMaaOSN.js";
+import "./manipulate-CeAgrUd6.js";
+import "./xyz-MII3ndWO.js";
+import "./lab-CJHLdqfe.js";
+import "./get-BFaklfVd.js";
+
+export { Colord, colord };

package/dist/extend-DrPfn2Q1.d.ts

@@ -0,0 +1,7 @@
+import { m as Parsers, t as Colord } from "./colord-xpgrVWRV.js";
+
+//#region src/extend.d.ts
+type Plugin = (ColordClass: typeof Colord, parsers: Parsers) => void;
+declare const extend: (plugins: Plugin[]) => void;
+//#endregion
+export { extend as n, Plugin as t };

package/dist/get-BFaklfVd.js

@@ -0,0 +1,92 @@
+import { o as rgbToLinearRgb } from "./rgb-CfVJB1Bj.js";
+
+//#region src/shared/get.ts
+/**
+* Returns the perceived luminance of a color [0-1] according to WCAG 2.0.
+* https://www.w3.org/TR/WCAG20/#relativeluminancedef
+*/
+const getLuminance = (rgb) => {
+	const { r, g, b } = rgbToLinearRgb(rgb);
+	return .2126 * r + .7152 * g + .0722 * b;
+};
+/**
+* Returns the brightness of a color [0-1].
+* https://www.w3.org/TR/AERT/#color-contrast
+* https://en.wikipedia.org/wiki/YIQ
+*/
+const getBrightness = (rgb) => {
+	return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3 / 255;
+};
+/**
+* Returns a contrast ratio for a color pair [1-21].
+* http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+*/
+const getContrast = (rgb1, rgb2) => {
+	const l1 = getLuminance(rgb1);
+	const l2 = getLuminance(rgb2);
+	return l1 > l2 ? (l1 + .05) / (l2 + .05) : (l2 + .05) / (l1 + .05);
+};
+/**
+* Calculates the perceived color difference according to [Delta E2000](https://en.wikipedia.org/wiki/Color_difference#CIEDE2000).
+*
+* ΔE - (Delta E, dE) The measure of change in visual perception of two given colors.
+*
+* Delta E is a metric for understanding how the human eye perceives color difference.
+* The term delta comes from mathematics, meaning change in a variable or function.
+* The suffix E references the German word Empfindung, which broadly means sensation.
+*
+* On a typical scale, the Delta E value will range from 0 to 100.
+*
+* | Delta E | Perception                             |
+* |---------|----------------------------------------|
+* | <= 1.0  | Not perceptible by human eyes          |
+* | 1 - 2   | Perceptible through close observation  |
+* | 2 - 10  | Perceptible at a glance                |
+* | 11 - 49 | Colors are more similar than opposite  |
+* | 100     | Colors are exact opposite              |
+*
+* [Source](http://www.brucelindbloom.com/index.html?Eqn_DeltaE_CIE2000.html)
+* [Read about Delta E](https://zschuessler.github.io/DeltaE/learn/#toc-delta-e-2000)
+*/
+function getDeltaE2000(color1, color2) {
+	const { l: l1, a: a1, b: b1 } = color1;
+	const { l: l2, a: a2, b: b2 } = color2;
+	const rad2deg = 180 / Math.PI;
+	const deg2rad = Math.PI / 180;
+	const mc = ((a1 ** 2 + b1 ** 2) ** .5 + (a2 ** 2 + b2 ** 2) ** .5) / 2;
+	const ml = (l1 + l2) / 2;
+	const c7 = mc ** 7;
+	const g = .5 * (1 - (c7 / (c7 + 25 ** 7)) ** .5);
+	const a11 = a1 * (1 + g);
+	const a22 = a2 * (1 + g);
+	const c11 = (a11 ** 2 + b1 ** 2) ** .5;
+	const c22 = (a22 ** 2 + b2 ** 2) ** .5;
+	const mc1 = (c11 + c22) / 2;
+	let h1 = a11 === 0 && b1 === 0 ? 0 : Math.atan2(b1, a11) * rad2deg;
+	let h2 = a22 === 0 && b2 === 0 ? 0 : Math.atan2(b2, a22) * rad2deg;
+	if (h1 < 0) h1 += 360;
+	if (h2 < 0) h2 += 360;
+	let dh = h2 - h1;
+	const dhAbs = Math.abs(h2 - h1);
+	if (dhAbs > 180 && h2 <= h1) dh += 360;
+	else if (dhAbs > 180 && h2 > h1) dh -= 360;
+	let H = h1 + h2;
+	if (dhAbs <= 180) H /= 2;
+	else H = (h1 + h2 < 360 ? H + 360 : H - 360) / 2;
+	const T = 1 - .17 * Math.cos(deg2rad * (H - 30)) + .24 * Math.cos(deg2rad * 2 * H) + .32 * Math.cos(deg2rad * (3 * H + 6)) - .2 * Math.cos(deg2rad * (4 * H - 63));
+	const dL = l2 - l1;
+	const dC = c22 - c11;
+	const dH = 2 * Math.sin(deg2rad * dh / 2) * (c11 * c22) ** .5;
+	const sL = 1 + .015 * (ml - 50) ** 2 / (20 + (ml - 50) ** 2) ** .5;
+	const sC = 1 + .045 * mc1;
+	const sH = 1 + .015 * mc1 * T;
+	const dTheta = 30 * Math.exp(-1 * ((H - 275) / 25) ** 2);
+	const Rt = -(2 * (c7 / (c7 + 25 ** 7)) ** .5) * Math.sin(deg2rad * 2 * dTheta);
+	const kl = 1;
+	const kc = 1;
+	const kh = 1;
+	return ((dL / kl / sL) ** 2 + (dC / kc / sC) ** 2 + (dH / kh / sH) ** 2 + Rt * dC * dH / (kc * sC * kh * sH)) ** .5;
+}
+
+//#endregion
+export { getLuminance as i, getContrast as n, getDeltaE2000 as r, getBrightness as t };

package/dist/hsv-UWMaaOSN.js

@@ -0,0 +1,78 @@
+import { _ as ALPHA_PRECISION, c as round, i as isPresent, n as clampHue, t as clamp } from "./utils-BgIyY6bK.js";
+
+//#region src/models/hsv.ts
+const clampHsv = (hsv) => ({
+	h: clampHue(hsv.h),
+	s: clamp(hsv.s, 0, 100),
+	v: clamp(hsv.v, 0, 100),
+	alpha: clamp(hsv.alpha)
+});
+const roundHsv = (hsv) => ({
+	h: round(hsv.h, 3),
+	s: round(hsv.s, 3),
+	v: round(hsv.v, 3),
+	alpha: round(hsv.alpha, ALPHA_PRECISION)
+});
+const hsvToRgb = (hsv) => {
+	const h = hsv.h / 360 * 6;
+	const s = hsv.s / 100;
+	const v = hsv.v / 100;
+	const hh = Math.floor(h);
+	const b = v * (1 - s);
+	const c = v * (1 - (h - hh) * s);
+	const d = v * (1 - (1 - h + hh) * s);
+	const module = hh % 6;
+	return {
+		r: [
+			v,
+			c,
+			b,
+			b,
+			d,
+			v
+		][module] * 255,
+		g: [
+			d,
+			v,
+			v,
+			c,
+			b,
+			b
+		][module] * 255,
+		b: [
+			b,
+			b,
+			d,
+			v,
+			v,
+			c
+		][module] * 255,
+		alpha: hsv.alpha
+	};
+};
+const parseHsv = ({ h, s, v, alpha = 1 }) => {
+	if (!isPresent(h) || !isPresent(s) || !isPresent(v)) return null;
+	return hsvToRgb(clampHsv({
+		h: Number(h),
+		s: Number(s),
+		v: Number(v),
+		alpha: Number(alpha)
+	}));
+};
+const rgbToHsv = ({ r, g, b, alpha }) => {
+	const max = Math.max(r, g, b);
+	const delta = max - Math.min(r, g, b);
+	let hh = 0;
+	if (delta) if (max === r) hh = (g - b) / delta;
+	else if (max === g) hh = 2 + (b - r) / delta;
+	else hh = 4 + (r - g) / delta;
+	return {
+		h: 60 * (hh < 0 ? hh + 6 : hh),
+		s: max ? delta / max * 100 : 0,
+		v: max / 255 * 100,
+		alpha
+	};
+};
+
+//#endregion
+export { roundHsv as i, parseHsv as n, rgbToHsv as r, hsvToRgb as t };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+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-xpgrVWRV.js";
+import { n as extend, t as Plugin } from "./extend-DrPfn2Q1.js";
+
+//#region src/shared/parse.d.ts
+
+/**
+ * Returns a color model name for the input passed to the function.
+ */
+declare const getFormat: (input: Input) => Format | undefined;
+//#endregion
+//#region src/shared/random.d.ts
+declare const random: () => Colord;
+//#endregion
+export { type AnyColor, Colord, type HslColor, type HsvColor, type HwbColor, type LabColor, type LchColor, type OklabColor, type OklchColor, type Plugin, type RgbColor, type XyzColor, colord, extend, getFormat, random };

package/dist/index.js

@@ -0,0 +1,22 @@
+import "./utils-BgIyY6bK.js";
+import "./rgb-CfVJB1Bj.js";
+import { a as parsers, i as getFormat, n as colord, r as random, t as Colord } from "./colord-BV1k1-gC.js";
+import "./hsv-UWMaaOSN.js";
+import "./manipulate-CeAgrUd6.js";
+import "./xyz-MII3ndWO.js";
+import "./lab-CJHLdqfe.js";
+import "./get-BFaklfVd.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 };