@tempots/std 0.27.0 → 0.28.1

package/color-gamut.js

@@ -0,0 +1,72 @@
+import { m as b, a4 as k, R as u } from "./color-SZxckS9U.js";
+const e = (t) => t <= 31308e-7 ? t * 12.92 : 1.055 * Math.pow(t, 1 / 2.4) - 0.055, i = (t, o, n) => [
+  3.2404542 * t - 1.5371385 * o - 0.4985314 * n,
+  -0.969266 * t + 1.8760108 * o + 0.041556 * n,
+  0.0556434 * t - 0.2040259 * o + 1.0572252 * n
+], d = 0.95047, _ = 1, M = 1.08883, T = 6 / 29, D = 3 * T ** 2, m = (t, o, n) => {
+  const s = (c) => c > T ? c ** 3 : D * (c - 0.13793103448275862), a = (t + 16) / 116, r = o / 500 + a, l = a - n / 200;
+  return [d * s(r), _ * s(a), M * s(l)];
+}, f = (t, o, n) => {
+  const s = t + 0.3963377774 * o + 0.2158037573 * n, a = t - 0.1055613458 * o - 0.0638541728 * n, r = t - 0.0894841775 * o - 1.291485548 * n, l = s * s * s, c = a * a * a, h = r * r * r;
+  return [
+    4.0767416621 * l - 3.3077115913 * c + 0.2309699292 * h,
+    -1.2684380046 * l + 2.6097574011 * c - 0.3413193965 * h,
+    -0.0041960863 * l - 0.7034186147 * c + 1.707614701 * h
+  ];
+}, I = (t, o, n) => {
+  const s = n * Math.PI / 180;
+  return [t, o * Math.cos(s), o * Math.sin(s)];
+}, S = (t, o, n) => {
+  const s = n * Math.PI / 180;
+  return [t, o * Math.cos(s), o * Math.sin(s)];
+}, x = (t) => {
+  switch (t.space) {
+    case "rgb":
+      return [t.r, t.g, t.b, t.alpha];
+    case "rgb8":
+      return [t.r / 255, t.g / 255, t.b / 255, t.alpha];
+    case "oklab": {
+      const [o, n, s] = f(t.l, t.a, t.b);
+      return [e(o), e(n), e(s), t.alpha];
+    }
+    case "oklch": {
+      const [o, n, s] = I(t.l, t.c, t.h), [a, r, l] = f(o, n, s);
+      return [e(a), e(r), e(l), t.alpha];
+    }
+    case "lab": {
+      const [o, n, s] = m(t.l, t.a, t.b), [a, r, l] = i(o, n, s);
+      return [e(a), e(r), e(l), t.alpha];
+    }
+    case "lch": {
+      const [o, n, s] = S(t.l, t.c, t.h), [a, r, l] = m(o, n, s), [c, h, g] = i(a, r, l);
+      return [e(c), e(h), e(g), t.alpha];
+    }
+    default: {
+      const o = b(t, "rgb8");
+      return [o.r / 255, o.g / 255, o.b / 255, o.alpha];
+    }
+  }
+}, p = (t, o = 2e-3) => {
+  const [n, s, a] = x(t);
+  return n >= -o && n <= 1 + o && s >= -o && s <= 1 + o && a >= -o && a <= 1 + o;
+}, z = (t) => {
+  if (p(t)) return t;
+  const o = t.space, n = b(t, "rgb8"), s = k(n.r, n.g, n.b, n.alpha);
+  return b(s, o);
+}, G = (t) => {
+  if (p(t)) return t;
+  const o = t.space, n = b(t, "oklch");
+  let s = 0, a = n.c;
+  const r = 1e-4;
+  for (let c = 0; c < 50 && a - s > r; c++) {
+    const h = (s + a) / 2, g = u(n.l, h, n.h, n.alpha);
+    p(g) ? s = h : a = h;
+  }
+  const l = u(n.l, s, n.h, n.alpha);
+  return b(l, o);
+};
+export {
+  z as clampToGamut,
+  G as clampToGamutOklch,
+  p as isInGamut
+};

package/color-harmony.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./number.cjs"),n=require("./color-D7FAmkht.cjs"),t=(o,e)=>{const a=o.space,r=n.convertColor(o,"oklch"),l=n.oklcha(r.l,r.c,s.wrapCircular(r.h+e,360),r.alpha);return n.convertColor(l,a)},c=o=>t(o,180),i=(o,e=30)=>[o,t(o,e),t(o,-e)],u=o=>[o,t(o,120),t(o,240)],m=o=>[o,t(o,150),t(o,210)],p=o=>[o,t(o,90),t(o,180),t(o,270)];exports.analogous=i;exports.complement=c;exports.splitComplementary=m;exports.tetradic=p;exports.triadic=u;

package/color-harmony.d.ts

@@ -0,0 +1,81 @@
+import { Color } from './color';
+/**
+ * Returns the complementary color by rotating the hue
+ * 180 degrees in OKLCH space.
+ *
+ * @param c - Any color value
+ * @returns The complementary color in the same color
+ *   space as the input
+ * @example
+ * ```ts
+ * const red = rgba(1, 0, 0, 1)
+ * const cyan = complement(red)
+ * ```
+ * @public
+ */
+export declare const complement: (c: Color) => Color;
+/**
+ * Returns an analogous color scheme consisting of the
+ * original color and two neighbors at the given angle
+ * offset.
+ *
+ * @param c - Any color value
+ * @param angle - The hue offset in degrees (default 30)
+ * @returns A triple of [original, +angle, -angle] in
+ *   the same color space as the input
+ * @example
+ * ```ts
+ * const red = rgba(1, 0, 0, 1)
+ * const [base, warm, cool] = analogous(red)
+ * ```
+ * @public
+ */
+export declare const analogous: (c: Color, angle?: number) => [Color, Color, Color];
+/**
+ * Returns a triadic color scheme consisting of the
+ * original color and two colors evenly spaced at 120
+ * degree intervals.
+ *
+ * @param c - Any color value
+ * @returns A triple of [original, +120, +240] in the
+ *   same color space as the input
+ * @example
+ * ```ts
+ * const red = rgba(1, 0, 0, 1)
+ * const [a, b, c] = triadic(red)
+ * ```
+ * @public
+ */
+export declare const triadic: (c: Color) => [Color, Color, Color];
+/**
+ * Returns a split-complementary color scheme consisting
+ * of the original color and two colors adjacent to its
+ * complement at 150 and 210 degree offsets.
+ *
+ * @param c - Any color value
+ * @returns A triple of [original, +150, +210] in the
+ *   same color space as the input
+ * @example
+ * ```ts
+ * const red = rgba(1, 0, 0, 1)
+ * const [base, left, right] = splitComplementary(red)
+ * ```
+ * @public
+ */
+export declare const splitComplementary: (c: Color) => [Color, Color, Color];
+/**
+ * Returns a tetradic (rectangular) color scheme
+ * consisting of the original color and three colors
+ * evenly spaced at 90 degree intervals.
+ *
+ * @param c - Any color value
+ * @returns A quadruple of [original, +90, +180, +270]
+ *   in the same color space as the input
+ * @example
+ * ```ts
+ * const red = rgba(1, 0, 0, 1)
+ * const [a, b, c, d] = tetradic(red)
+ * ```
+ * @public
+ */
+export declare const tetradic: (c: Color) => [Color, Color, Color, Color];

package/color-harmony.js

@@ -0,0 +1,35 @@
+import { wrapCircular as l } from "./number.js";
+import { m as n, R as i } from "./color-SZxckS9U.js";
+const t = (o, r) => {
+  const s = o.space, a = n(o, "oklch"), e = i(
+    a.l,
+    a.c,
+    l(a.h + r, 360),
+    a.alpha
+  );
+  return n(e, s);
+}, c = (o) => t(o, 180), h = (o, r = 30) => [
+  o,
+  t(o, r),
+  t(o, -r)
+], u = (o) => [
+  o,
+  t(o, 120),
+  t(o, 240)
+], d = (o) => [
+  o,
+  t(o, 150),
+  t(o, 210)
+], k = (o) => [
+  o,
+  t(o, 90),
+  t(o, 180),
+  t(o, 270)
+];
+export {
+  h as analogous,
+  c as complement,
+  d as splitComplementary,
+  k as tetradic,
+  u as triadic
+};

package/color-hsl.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./error.cjs");require("./number.cjs");const r=require("./color-D7FAmkht.cjs");exports.canParseHsl=r.canParseHsl;exports.hslaToHslString=r.hslaToHslString;exports.hslaToRgb8a=r.hslaToRgb8a;exports.parseHsl=r.parseHsl;exports.rgb8aToHsla=r.rgb8aToHsla;

package/color-hsl.d.ts

@@ -0,0 +1,81 @@
+import { RGB8A, HSLA } from './color';
+/**
+ * Returns `true` if the string can be parsed as an `hsl()` or `hsla()` color.
+ *
+ * Supports both legacy comma-separated and modern space-separated syntax.
+ *
+ * @param s - The string to test.
+ * @returns `true` if the string is a valid HSL functional notation.
+ * @public
+ * @example
+ * ```ts
+ * canParseHsl('hsl(0, 100%, 50%)') // true
+ * canParseHsl('hsl(120 50% 50% / 0.5)') // true
+ * canParseHsl('#ff0000') // false
+ * ```
+ */
+export declare const canParseHsl: (s: string) => boolean;
+/**
+ * Parses an `hsl()` or `hsla()` color string into an HSLA color.
+ *
+ * Supports both legacy comma-separated and modern space-separated syntax.
+ *
+ * @param s - The string to parse.
+ * @returns An HSLA color.
+ * @throws ParsingError if the string is not a valid HSL color.
+ * @public
+ * @example
+ * ```ts
+ * parseHsl('hsl(0, 100%, 50%)') // hsla(0, 100, 50)
+ * parseHsl('hsla(120, 50%, 75%, 0.8)') // hsla(120, 50, 75, 0.8)
+ * parseHsl('hsl(240 100% 50% / 50%)') // hsla(240, 100, 50, 0.5)
+ * ```
+ */
+export declare const parseHsl: (s: string) => HSLA;
+/**
+ * Converts an RGB8A color to an HSLA color using the standard min/max/delta
+ * algorithm.
+ *
+ * @param c - The RGB8A color to convert.
+ * @returns The equivalent HSLA color.
+ * @public
+ * @example
+ * ```ts
+ * rgb8aToHsla(rgb8a(255, 0, 0)) // hsla(0, 100, 50)
+ * rgb8aToHsla(rgb8a(0, 128, 0)) // hsla(120, 100, ~25.1)
+ * rgb8aToHsla(rgb8a(0, 0, 0)) // hsla(0, 0, 0)
+ * ```
+ */
+export declare const rgb8aToHsla: (c: RGB8A) => HSLA;
+/**
+ * Converts an HSLA color to an RGB8A color using sector-based hue-to-RGB
+ * conversion.
+ *
+ * @param c - The HSLA color to convert.
+ * @returns The equivalent RGB8A color.
+ * @public
+ * @example
+ * ```ts
+ * hslaToRgb8a(hsla(0, 100, 50)) // rgb8a(255, 0, 0)
+ * hslaToRgb8a(hsla(120, 100, 50)) // rgb8a(0, 255, 0)
+ * hslaToRgb8a(hsla(240, 100, 50)) // rgb8a(0, 0, 255)
+ * ```
+ */
+export declare const hslaToRgb8a: (c: HSLA) => RGB8A;
+/**
+ * Serializes an HSLA color to an `hsl()` or `hsla()` CSS string.
+ *
+ * Produces `hsl(h, s%, l%)` when alpha is 1, or `hsla(h, s%, l%, alpha)`
+ * otherwise. Hue, saturation, and lightness are rounded to two decimal
+ * places for readability.
+ *
+ * @param c - The HSLA color to serialize.
+ * @returns A CSS color string.
+ * @public
+ * @example
+ * ```ts
+ * hslaToHslString(hsla(0, 100, 50)) // 'hsl(0, 100%, 50%)'
+ * hslaToHslString(hsla(120, 50, 75, 0.5)) // 'hsla(120, 50%, 75%, 0.5)'
+ * ```
+ */
+export declare const hslaToHslString: (c: HSLA) => string;

package/color-hsl.js

@@ -0,0 +1,10 @@
+import "./error.js";
+import "./number.js";
+import { b as l, p, r as t, X as H, a6 as b } from "./color-SZxckS9U.js";
+export {
+  l as canParseHsl,
+  p as hslaToHslString,
+  t as hslaToRgb8a,
+  H as parseHsl,
+  b as rgb8aToHsla
+};

package/color-hsv.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./error.cjs");require("./number.cjs");const s=require("./color-D7FAmkht.cjs");exports.canParseHsv=s.canParseHsv;exports.hslaToHsva=s.hslaToHsva;exports.hsvaToHsla=s.hsvaToHsla;exports.hsvaToHsvString=s.hsvaToHsvString;exports.hsvaToRgb8a=s.hsvaToRgb8a;exports.parseHsv=s.parseHsv;exports.rgb8aToHsva=s.rgb8aToHsva;

package/color-hsv.d.ts

@@ -0,0 +1,116 @@
+import { RGB8A, HSVA, HSLA } from './color';
+/**
+ * Returns `true` if the string can be parsed as an `hsv()` or `hsva()` color.
+ *
+ * This is a non-standard format commonly used in design tools such as Figma
+ * and Sketch. Supports both legacy comma-separated and modern
+ * space-separated syntax.
+ *
+ * @param s - The string to test.
+ * @returns `true` if the string is a valid HSV functional notation.
+ * @public
+ * @example
+ * ```ts
+ * canParseHsv('hsv(0, 100%, 100%)') // true
+ * canParseHsv('hsv(120 50% 80% / 0.5)') // true
+ * canParseHsv('hsl(0, 100%, 50%)') // false
+ * ```
+ */
+export declare const canParseHsv: (s: string) => boolean;
+/**
+ * Parses an `hsv()` or `hsva()` color string into an HSVA color.
+ *
+ * Supports both legacy comma-separated and modern space-separated syntax.
+ *
+ * @param s - The string to parse.
+ * @returns An HSVA color.
+ * @throws ParsingError if the string is not a valid HSV color.
+ * @public
+ * @example
+ * ```ts
+ * parseHsv('hsv(0, 100%, 100%)') // hsva(0, 100, 100)
+ * parseHsv('hsva(120, 50%, 80%, 0.5)') // hsva(120, 50, 80, 0.5)
+ * parseHsv('hsv(240 25% 90% / 50%)') // hsva(240, 25, 90, 0.5)
+ * ```
+ */
+export declare const parseHsv: (s: string) => HSVA;
+/**
+ * Converts an RGB8A color to an HSVA color.
+ *
+ * Uses the standard RGB-to-HSV algorithm where Value is the maximum channel
+ * and Saturation is the ratio of chroma to Value.
+ *
+ * @param c - The RGB8A color to convert.
+ * @returns An HSVA color.
+ * @public
+ * @example
+ * ```ts
+ * rgb8aToHsva(rgb8a(255, 0, 0)) // hsva(0, 100, 100)
+ * rgb8aToHsva(rgb8a(0, 0, 0)) // hsva(0, 0, 0)
+ * rgb8aToHsva(rgb8a(128, 128, 128)) // hsva(0, 0, ~50.2)
+ * ```
+ */
+export declare const rgb8aToHsva: (c: RGB8A) => HSVA;
+/**
+ * Converts an HSVA color to an RGB8A color.
+ *
+ * Uses the standard HSV-to-RGB algorithm with chroma, hue sectors, and an
+ * offset to produce final channel values.
+ *
+ * @param c - The HSVA color to convert.
+ * @returns An RGB8A color.
+ * @public
+ * @example
+ * ```ts
+ * hsvaToRgb8a(hsva(0, 100, 100)) // rgb8a(255, 0, 0)
+ * hsvaToRgb8a(hsva(120, 100, 100)) // rgb8a(0, 255, 0)
+ * hsvaToRgb8a(hsva(0, 0, 0)) // rgb8a(0, 0, 0)
+ * ```
+ */
+export declare const hsvaToRgb8a: (c: HSVA) => RGB8A;
+/**
+ * Converts an HSLA color to an HSVA color using a direct formula that
+ * avoids an intermediate RGB conversion.
+ *
+ * @param c - The HSLA color to convert.
+ * @returns An HSVA color.
+ * @public
+ * @example
+ * ```ts
+ * hslaToHsva(hsla(0, 100, 50)) // hsva(0, 100, 100)
+ * hslaToHsva(hsla(0, 0, 0)) // hsva(0, 0, 0)
+ * hslaToHsva(hsla(120, 50, 75)) // hsva(120, ~33.3, ~87.5)
+ * ```
+ */
+export declare const hslaToHsva: (c: HSLA) => HSVA;
+/**
+ * Converts an HSVA color to an HSLA color using a direct formula that
+ * avoids an intermediate RGB conversion.
+ *
+ * @param c - The HSVA color to convert.
+ * @returns An HSLA color.
+ * @public
+ * @example
+ * ```ts
+ * hsvaToHsla(hsva(0, 100, 100)) // hsla(0, 100, 50)
+ * hsvaToHsla(hsva(0, 0, 0)) // hsla(0, 0, 0)
+ * hsvaToHsla(hsva(120, 50, 80)) // hsla(120, ~47.1, 60)
+ * ```
+ */
+export declare const hsvaToHsla: (c: HSVA) => HSLA;
+/**
+ * Serializes an HSVA color to an `hsv()` or `hsva()` string.
+ *
+ * Produces `hsv(h, s%, v%)` when alpha is 1, or `hsva(h, s%, v%, a)`
+ * otherwise.
+ *
+ * @param c - The HSVA color to serialize.
+ * @returns An HSV color string.
+ * @public
+ * @example
+ * ```ts
+ * hsvaToHsvString(hsva(0, 100, 100)) // 'hsv(0, 100%, 100%)'
+ * hsvaToHsvString(hsva(120, 50, 80, 0.5)) // 'hsva(120, 50%, 80%, 0.5)'
+ * ```
+ */
+export declare const hsvaToHsvString: (c: HSVA) => string;

package/color-hsv.js

@@ -0,0 +1,12 @@
+import "./error.js";
+import "./number.js";
+import { d as r, q as H, t, u as T, v as h, Y as p, a7 as e } from "./color-SZxckS9U.js";
+export {
+  r as canParseHsv,
+  H as hslaToHsva,
+  t as hsvaToHsla,
+  T as hsvaToHsvString,
+  h as hsvaToRgb8a,
+  p as parseHsv,
+  e as rgb8aToHsva
+};

package/color-hwb.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./error.cjs");require("./number.cjs");const b=require("./color-D7FAmkht.cjs");exports.canParseHwb=b.canParseHwb;exports.hwbaToHwbString=b.hwbaToHwbString;exports.hwbaToRgb8a=b.hwbaToRgb8a;exports.parseHwb=b.parseHwb;exports.rgb8aToHwba=b.rgb8aToHwba;

package/color-hwb.d.ts

@@ -0,0 +1,88 @@
+import { RGB8A, HWBA } from './color';
+/**
+ * Returns `true` if the string can be parsed as an `hwb()` CSS Level 4 color.
+ *
+ * Only the modern space-separated syntax is supported:
+ * `hwb(h w% b%)` or `hwb(h w% b% / alpha)`.
+ *
+ * @param s - The string to test.
+ * @returns `true` if the string is a valid HWB functional notation.
+ * @public
+ * @example
+ * ```ts
+ * canParseHwb('hwb(0 0% 0%)') // true
+ * canParseHwb('hwb(180 20% 30% / 0.5)') // true
+ * canParseHwb('rgb(255, 0, 0)') // false
+ * ```
+ */
+export declare const canParseHwb: (s: string) => boolean;
+/**
+ * Parses an `hwb()` CSS Level 4 color string into an HWBA color.
+ *
+ * Only the modern space-separated syntax is supported:
+ * `hwb(h w% b%)` or `hwb(h w% b% / alpha)`.
+ *
+ * @param s - The string to parse.
+ * @returns An HWBA color.
+ * @throws ParsingError if the string is not a valid HWB color.
+ * @public
+ * @example
+ * ```ts
+ * parseHwb('hwb(0 0% 0%)') // hwba(0, 0, 0)
+ * parseHwb('hwb(180 20% 30%)') // hwba(180, 20, 30)
+ * parseHwb('hwb(90 10% 20% / 0.5)') // hwba(90, 10, 20, 0.5)
+ * ```
+ */
+export declare const parseHwb: (s: string) => HWBA;
+/**
+ * Converts an RGB8A color to an HWBA color.
+ *
+ * The conversion derives hue, whiteness, and blackness from the RGB channels.
+ * Whiteness is the minimum channel value and blackness is one minus the maximum
+ * channel value.
+ *
+ * @param c - The RGB8A color to convert.
+ * @returns An HWBA color.
+ * @public
+ * @example
+ * ```ts
+ * rgb8aToHwba(rgb8a(255, 0, 0)) // hwba(0, 0, 0)
+ * rgb8aToHwba(rgb8a(0, 0, 0)) // hwba(0, 0, 100)
+ * rgb8aToHwba(rgb8a(255, 255, 255)) // hwba(0, 100, 0)
+ * ```
+ */
+export declare const rgb8aToHwba: (c: RGB8A) => HWBA;
+/**
+ * Converts an HWBA color to an RGB8A color.
+ *
+ * When whiteness plus blackness exceed 100%, they are proportionally scaled
+ * so that their sum equals 100%. The pure hue color is then blended between
+ * white and black according to the whiteness and blackness values.
+ *
+ * @param c - The HWBA color to convert.
+ * @returns An RGB8A color.
+ * @public
+ * @example
+ * ```ts
+ * hwbaToRgb8a(hwba(0, 0, 0)) // rgb8a(255, 0, 0)
+ * hwbaToRgb8a(hwba(0, 100, 0)) // rgb8a(255, 255, 255)
+ * hwbaToRgb8a(hwba(0, 0, 100)) // rgb8a(0, 0, 0)
+ * ```
+ */
+export declare const hwbaToRgb8a: (c: HWBA) => RGB8A;
+/**
+ * Serializes an HWBA color to a CSS `hwb()` string.
+ *
+ * Produces `hwb(h w% b%)` when alpha is 1, or `hwb(h w% b% / alpha)`
+ * otherwise.
+ *
+ * @param c - The HWBA color to serialize.
+ * @returns A CSS `hwb()` color string.
+ * @public
+ * @example
+ * ```ts
+ * hwbaToHwbString(hwba(0, 0, 0)) // 'hwb(0 0% 0%)'
+ * hwbaToHwbString(hwba(180, 20, 30, 0.5)) // 'hwb(180 20% 30% / 0.5)'
+ * ```
+ */
+export declare const hwbaToHwbString: (c: HWBA) => string;

package/color-hwb.js

@@ -0,0 +1,10 @@
+import "./error.js";
+import "./number.js";
+import { e as s, x as w, y as e, Z as p, a8 as t } from "./color-SZxckS9U.js";
+export {
+  s as canParseHwb,
+  w as hwbaToHwbString,
+  e as hwbaToRgb8a,
+  p as parseHwb,
+  t as rgb8aToHwba
+};

package/color-lab.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./error.cjs");require("./number.cjs");const a=require("./color-D7FAmkht.cjs");exports.canParseLab=a.canParseLab;exports.canParseLch=a.canParseLch;exports.labaToLabString=a.labaToLabString;exports.labaToRgb8a=a.labaToRgb8a;exports.lchaToLchString=a.lchaToLchString;exports.lchaToRgb8a=a.lchaToRgb8a;exports.parseLab=a.parseLab;exports.parseLch=a.parseLch;exports.rgb8aToLaba=a.rgb8aToLaba;exports.rgb8aToLcha=a.rgb8aToLcha;

package/color-lab.d.ts

@@ -0,0 +1,161 @@
+import { RGB8A, LABA, LCHA } from './color';
+/**
+ * Returns `true` if the string can be parsed as a `lab()` color.
+ *
+ * @param s - The string to test.
+ * @returns `true` if the string is a valid LAB functional notation.
+ * @public
+ * @example
+ * ```ts
+ * canParseLab('lab(50 -20 30)') // true
+ * canParseLab('lab(50% -20 30 / 0.5)') // true
+ * canParseLab('#ff0000') // false
+ * ```
+ */
+export declare const canParseLab: (s: string) => boolean;
+/**
+ * Parses a `lab()` color string into a LABA color.
+ *
+ * Supports `lab(L a b)` and `lab(L a b / alpha)` syntax. The lightness
+ * value can be a percentage (0–100%) or a plain number (0–100). The `a`
+ * and `b` axes accept any number, including negatives.
+ *
+ * @param s - The string to parse.
+ * @returns A LABA color.
+ * @throws ParsingError if the string is not a valid LAB color.
+ * @public
+ * @example
+ * ```ts
+ * parseLab('lab(50 -20 30)') // laba(50, -20, 30)
+ * parseLab('lab(50% -20 30 / 0.5)') // laba(50, -20, 30, 0.5)
+ * ```
+ */
+export declare const parseLab: (s: string) => LABA;
+/**
+ * Returns `true` if the string can be parsed as an `lch()` color.
+ *
+ * @param s - The string to test.
+ * @returns `true` if the string is a valid LCH functional notation.
+ * @public
+ * @example
+ * ```ts
+ * canParseLch('lch(50 36 326)') // true
+ * canParseLch('lch(50% 36 326 / 0.8)') // true
+ * canParseLch('rgb(0,0,0)') // false
+ * ```
+ */
+export declare const canParseLch: (s: string) => boolean;
+/**
+ * Parses an `lch()` color string into a LCHA color.
+ *
+ * Supports `lch(L C H)` and `lch(L C H / alpha)` syntax. The lightness
+ * value can be a percentage (0–100%) or a plain number (0–100). Chroma
+ * must be non-negative, and hue is an angle in degrees.
+ *
+ * @param s - The string to parse.
+ * @returns A LCHA color.
+ * @throws ParsingError if the string is not a valid LCH color.
+ * @public
+ * @example
+ * ```ts
+ * parseLch('lch(50 36 326)') // lcha(50, 36, 326)
+ * parseLch('lch(75% 40 120 / 50%)') // lcha(75, 40, 120, 0.5)
+ * ```
+ */
+export declare const parseLch: (s: string) => LCHA;
+/**
+ * Converts an RGB8A color to a LABA color through the CIE XYZ intermediate
+ * color space.
+ *
+ * @param c - The RGB8A color to convert.
+ * @returns The equivalent LABA color.
+ * @public
+ * @example
+ * ```ts
+ * rgb8aToLaba(rgb8a(255, 0, 0)) // laba(~53.23, ~80.11, ~67.22)
+ * rgb8aToLaba(rgb8a(0, 0, 0))   // laba(0, 0, 0)
+ * ```
+ */
+export declare const rgb8aToLaba: (c: RGB8A) => LABA;
+/**
+ * Converts a LABA color to an RGB8A color through the CIE XYZ intermediate
+ * color space.
+ *
+ * Channel values are clamped to the sRGB gamut before rounding.
+ *
+ * @param c - The LABA color to convert.
+ * @returns The equivalent RGB8A color.
+ * @public
+ * @example
+ * ```ts
+ * labaToRgb8a(laba(53.23, 80.11, 67.22)) // rgb8a(~255, ~0, ~0)
+ * labaToRgb8a(laba(0, 0, 0))             // rgb8a(0, 0, 0)
+ * ```
+ */
+export declare const labaToRgb8a: (c: LABA) => RGB8A;
+/**
+ * Converts an RGB8A color to a LCHA color by converting to LABA first and
+ * then applying the polar (cylindrical) transformation.
+ *
+ * @param c - The RGB8A color to convert.
+ * @returns The equivalent LCHA color.
+ * @public
+ * @example
+ * ```ts
+ * rgb8aToLcha(rgb8a(255, 0, 0)) // lcha(~53.23, ~104.55, ~40.0)
+ * rgb8aToLcha(rgb8a(0, 0, 0))   // lcha(0, 0, 0)
+ * ```
+ */
+export declare const rgb8aToLcha: (c: RGB8A) => LCHA;
+/**
+ * Converts a LCHA color to an RGB8A color by converting from polar
+ * coordinates to rectangular LAB and then to RGB8A.
+ *
+ * @param c - The LCHA color to convert.
+ * @returns The equivalent RGB8A color.
+ * @public
+ * @example
+ * ```ts
+ * lchaToRgb8a(lcha(53.23, 104.55, 40.0)) // rgb8a(~255, ~0, ~0)
+ * lchaToRgb8a(lcha(0, 0, 0))             // rgb8a(0, 0, 0)
+ * ```
+ */
+export declare const lchaToRgb8a: (c: LCHA) => RGB8A;
+/**
+ * Serializes a LABA color to a `lab()` CSS string.
+ *
+ * Produces `lab(L a b)` when alpha is 1, or `lab(L a b / alpha)` otherwise.
+ * Lightness is rounded to 2 decimal places; `a` and `b` axes are rounded
+ * to 4 decimal places.
+ *
+ * @param c - The LABA color to serialize.
+ * @returns A CSS `lab()` color string.
+ * @public
+ * @example
+ * ```ts
+ * labaToLabString(laba(50, -20, 30))
+ * // 'lab(50 -20 30)'
+ * labaToLabString(laba(50, -20, 30, 0.5))
+ * // 'lab(50 -20 30 / 0.5)'
+ * ```
+ */
+export declare const labaToLabString: (c: LABA) => string;
+/**
+ * Serializes a LCHA color to an `lch()` CSS string.
+ *
+ * Produces `lch(L C H)` when alpha is 1, or `lch(L C H / alpha)` otherwise.
+ * Lightness is rounded to 2 decimal places; chroma and hue are rounded to
+ * 4 decimal places.
+ *
+ * @param c - The LCHA color to serialize.
+ * @returns A CSS `lch()` color string.
+ * @public
+ * @example
+ * ```ts
+ * lchaToLchString(lcha(50, 36, 326))
+ * // 'lch(50 36 326)'
+ * lchaToLchString(lcha(50, 36, 326, 0.8))
+ * // 'lch(50 36 326 / 0.8)'
+ * ```
+ */
+export declare const lchaToLchString: (c: LCHA) => string;