@design-edito/tools 0.3.16 → 0.4.0

package/chunks/chunk-CVMYA5XK.js

@@ -0,0 +1,632 @@
+import {
+  cssColors,
+  isCmyk,
+  isCssColor,
+  isHex,
+  isHsb,
+  isHsl,
+  isLab,
+  isLch,
+  isRgb,
+  isXyz
+} from "./chunk-OBSTP7YR.js";
+import {
+  absoluteModulo
+} from "./chunk-DNIOWD7K.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+
+// src/agnostic/colors/convert/index.ts
+function _hex2rgb(hex) {
+  if (!isHex(hex)) throw new Error(`invalid hex color ${unknownToString(hex)}`);
+  let hexString = hex;
+  const inputHex = hexString;
+  const startsWithHash = hexString.startsWith("#");
+  if (!startsWithHash) throw new Error(`invalid hex color ${inputHex}`);
+  hexString = hexString.slice(1);
+  if (hexString.length === 3) {
+    hexString = hexString.split("").map((c) => c + c).join("") + "ff";
+  } else if (hexString.length === 4) {
+    hexString = hexString.split("").map((c) => c + c).join("");
+  } else if (hexString.length === 6) {
+    hexString = hexString + "ff";
+  } else if (hexString.length !== 8) throw new Error(`invalid hex color ${inputHex}`);
+  const r = parseInt(hexString.slice(0, 2), 16);
+  const g = parseInt(hexString.slice(2, 4), 16);
+  const b = parseInt(hexString.slice(4, 6), 16);
+  const a = parseInt(hexString.slice(6, 8), 16) / 255;
+  return { r, g, b, a };
+}
+function _rgb2hex(rgb) {
+  const { r, g, b, a = 1 } = rgb;
+  const rHex = Math.round(r).toString(16).padStart(2, "0");
+  const gHex = Math.round(g).toString(16).padStart(2, "0");
+  const bHex = Math.round(b).toString(16).padStart(2, "0");
+  const aHex = Math.round(a * 255).toString(16).padStart(2, "0");
+  const returned = `#${rHex}${gHex}${bHex}${aHex}`;
+  if (!isHex(returned)) {
+    throw new Error(`invalid hex color output ${unknownToString(returned)}`);
+  }
+  return returned;
+}
+function _css2rgb(color) {
+  if (color in cssColors) return cssColors[color];
+  return void 0;
+}
+var cssColorsWithHex = Object.entries(cssColors).map(([cssColor, rgba]) => ({
+  name: cssColor,
+  hex: _rgb2hex(rgba),
+  rgba
+}));
+function _rgb2css(rgb) {
+  const hexTarget = _rgb2hex(rgb);
+  return cssColorsWithHex.find((c) => c.hex === hexTarget)?.name;
+}
+function _hsl2rgb(hsl) {
+  const { h, s, l, a = 1 } = hsl;
+  const H = absoluteModulo(h, 360) / 360;
+  const S = Math.max(0, Math.min(1, s / 100));
+  const L = Math.max(0, Math.min(1, l / 100));
+  const A = Math.max(0, Math.min(1, a));
+  const hue2rgb = (p, q, t) => {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 1 / 2) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  };
+  let r;
+  let g;
+  let b;
+  if (S === 0) {
+    r = g = b = L;
+  } else {
+    const q = L < 0.5 ? L * (1 + S) : L + S - L * S;
+    const p = 2 * L - q;
+    r = hue2rgb(p, q, H + 1 / 3);
+    g = hue2rgb(p, q, H);
+    b = hue2rgb(p, q, H - 1 / 3);
+  }
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(b * 255),
+    a: A
+  };
+}
+function _rgb2hsl(rgb) {
+  const { r, g, b, a = 1 } = rgb;
+  const R = r / 255;
+  const G = g / 255;
+  const B = b / 255;
+  const max = Math.max(R, G, B);
+  const min = Math.min(R, G, B);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+    if (max === R) {
+      h = ((G - B) / delta + (G < B ? 6 : 0)) / 6;
+    } else if (max === G) {
+      h = ((B - R) / delta + 2) / 6;
+    } else {
+      h = ((R - G) / delta + 4) / 6;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100),
+    a
+  };
+}
+function _hsb2rgb(hsb) {
+  const { h, s, b, a = 1 } = hsb;
+  const H = absoluteModulo(h, 360) / 360;
+  const S = Math.max(0, Math.min(1, s / 100));
+  const B = Math.max(0, Math.min(1, b / 100));
+  const A = Math.max(0, Math.min(1, a));
+  const i = Math.floor(H * 6);
+  const f = H * 6 - i;
+  const p = B * (1 - S);
+  const q = B * (1 - f * S);
+  const t = B * (1 - (1 - f) * S);
+  let r;
+  let g;
+  let blue;
+  switch (absoluteModulo(i, 6)) {
+    case 0:
+      r = B;
+      g = t;
+      blue = p;
+      break;
+    case 1:
+      r = q;
+      g = B;
+      blue = p;
+      break;
+    case 2:
+      r = p;
+      g = B;
+      blue = t;
+      break;
+    case 3:
+      r = p;
+      g = q;
+      blue = B;
+      break;
+    case 4:
+      r = t;
+      g = p;
+      blue = B;
+      break;
+    case 5:
+      r = B;
+      g = p;
+      blue = q;
+      break;
+    default:
+      r = g = blue = 0;
+  }
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(blue * 255),
+    a: A
+  };
+}
+function _rgb2hsb(rgb) {
+  const { r, g, b, a = 1 } = rgb;
+  const R = r / 255;
+  const G = g / 255;
+  const B = b / 255;
+  const max = Math.max(R, G, B);
+  const min = Math.min(R, G, B);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const brightness = max;
+  if (max !== 0) {
+    s = delta / max;
+  }
+  if (delta !== 0) {
+    if (max === R) {
+      h = ((G - B) / delta + (G < B ? 6 : 0)) / 6;
+    } else if (max === G) {
+      h = ((B - R) / delta + 2) / 6;
+    } else {
+      h = ((R - G) / delta + 4) / 6;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    b: Math.round(brightness * 100),
+    a
+  };
+}
+function _cmyk2rgb(cmyka) {
+  const { c, m, y, k, a = 1 } = cmyka;
+  const C = Math.max(0, Math.min(100, c)) / 100;
+  const M = Math.max(0, Math.min(100, m)) / 100;
+  const Y = Math.max(0, Math.min(100, y)) / 100;
+  const K = Math.max(0, Math.min(100, k)) / 100;
+  const A = Math.max(0, Math.min(1, a));
+  const R = 1 - Math.min(1, C * (1 - K) + K);
+  const G = 1 - Math.min(1, M * (1 - K) + K);
+  const B = 1 - Math.min(1, Y * (1 - K) + K);
+  return {
+    r: Math.round(R * 255),
+    g: Math.round(G * 255),
+    b: Math.round(B * 255),
+    a: A
+  };
+}
+function _rgb2cmyk(rgb) {
+  const { r, g, b, a = 1 } = rgb;
+  const R = Math.max(0, Math.min(1, r / 255));
+  const G = Math.max(0, Math.min(1, g / 255));
+  const B = Math.max(0, Math.min(1, b / 255));
+  const A = Math.max(0, Math.min(1, a));
+  const K = 1 - Math.max(R, G, B);
+  const denom = 1 - K || 1;
+  const C = (1 - R - K) / denom;
+  const M = (1 - G - K) / denom;
+  const Y = (1 - B - K) / denom;
+  return {
+    c: Math.round(C * 100),
+    m: Math.round(M * 100),
+    y: Math.round(Y * 100),
+    k: Math.round(K * 100),
+    a: A
+  };
+}
+function _xyz2rgb(xyza) {
+  const { x, y, z, a = 1 } = xyza;
+  const X = x / 100;
+  const Y = y / 100;
+  const Z = z / 100;
+  const A = Math.max(0, Math.min(1, a));
+  let R = X * 3.2404542 + Y * -1.5371385 + Z * -0.4985314;
+  let G = X * -0.969266 + Y * 1.8760108 + Z * 0.041556;
+  let B = X * 0.0556434 + Y * -0.2040259 + Z * 1.0572252;
+  const GAMMA_THRESHOLD = 31308e-7;
+  const GAMMA_EXPONENT = 1 / 2.4;
+  const GAMMA_MULT = 1.055;
+  const GAMMA_OFFSET = 0.055;
+  const LINEAR_DIVISOR = 12.92;
+  const gammaCorrect = (c) => c <= GAMMA_THRESHOLD ? c * LINEAR_DIVISOR : GAMMA_MULT * Math.pow(c, GAMMA_EXPONENT) - GAMMA_OFFSET;
+  R = gammaCorrect(R);
+  G = gammaCorrect(G);
+  B = gammaCorrect(B);
+  return {
+    r: Math.round(Math.max(0, Math.min(1, R)) * 255),
+    g: Math.round(Math.max(0, Math.min(1, G)) * 255),
+    b: Math.round(Math.max(0, Math.min(1, B)) * 255),
+    a: A
+  };
+}
+function _rgb2xyz(rgb) {
+  const { r, g, b, a = 1 } = rgb;
+  let R = Math.max(0, Math.min(1, r / 255));
+  let G = Math.max(0, Math.min(1, g / 255));
+  let B = Math.max(0, Math.min(1, b / 255));
+  const A = Math.max(0, Math.min(1, a));
+  const SRGB_THRESHOLD = 0.04045;
+  const SRGB_OFFSET = 0.055;
+  const SRGB_DIVISOR = 1.055;
+  const SRGB_EXPONENT = 2.4;
+  const SRGB_LINEAR_DIVISOR = 12.92;
+  const linearize = (c) => c > SRGB_THRESHOLD ? Math.pow((c + SRGB_OFFSET) / SRGB_DIVISOR, SRGB_EXPONENT) : c / SRGB_LINEAR_DIVISOR;
+  R = linearize(R);
+  G = linearize(G);
+  B = linearize(B);
+  const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;
+  const Y = R * 0.2126729 + G * 0.7151522 + B * 0.072175;
+  const Z = R * 0.0193339 + G * 0.119192 + B * 0.9503041;
+  return {
+    x: X * 100,
+    y: Y * 100,
+    z: Z * 100,
+    a: A
+  };
+}
+function _lab2xyz(lab) {
+  const { l, a: A = 0, b: B = 0, al: alpha = 1 } = lab;
+  const REF_X = 95.047;
+  const REF_Y = 100;
+  const REF_Z = 108.883;
+  const fy = (l + 16) / 116;
+  const fx = fy + A / 500;
+  const fz = fy - B / 200;
+  const fx3 = Math.pow(fx, 3);
+  const fz3 = Math.pow(fz, 3);
+  const fy3 = Math.pow(fy, 3);
+  const epsilon = 8856e-6;
+  const kappa = 903.3;
+  const X = fx3 > epsilon ? fx3 : (116 * fx - 16) / kappa;
+  const Y = l > kappa * epsilon ? fy3 : l / kappa;
+  const Z = fz3 > epsilon ? fz3 : (116 * fz - 16) / kappa;
+  return {
+    x: X * REF_X,
+    y: Y * REF_Y,
+    z: Z * REF_Z,
+    a: Math.max(0, Math.min(1, alpha))
+  };
+}
+function _xyz2lab(xyza) {
+  const { x, y, z, a: alpha = 1 } = xyza;
+  const REF_X = 95.047;
+  const REF_Y = 100;
+  const REF_Z = 108.883;
+  const X = x / REF_X;
+  const Y = y / REF_Y;
+  const Z = z / REF_Z;
+  const epsilon = 8856e-6;
+  const kappa = 903.3;
+  const fx = X > epsilon ? Math.cbrt(X) : (kappa * X + 16) / 116;
+  const fy = Y > epsilon ? Math.cbrt(Y) : (kappa * Y + 16) / 116;
+  const fz = Z > epsilon ? Math.cbrt(Z) : (kappa * Z + 16) / 116;
+  const L = 116 * fy - 16;
+  const A = 500 * (fx - fy);
+  const B = 200 * (fy - fz);
+  return {
+    l: L,
+    a: A,
+    b: B,
+    al: Math.max(0, Math.min(1, alpha))
+  };
+}
+function _lab2lch(lab) {
+  const { l, a, b, al = 1 } = lab;
+  const c = Math.sqrt(a * a + b * b);
+  let h = Math.atan2(b, a) * (180 / Math.PI);
+  if (h < 0) h += 360;
+  return { l, c, h, a: al };
+}
+function _lch2lab(lch) {
+  const { l, c, h, a = 1 } = lch;
+  const hRad = h * Math.PI / 180;
+  const A = c * Math.cos(hRad);
+  const B = c * Math.sin(hRad);
+  return { l, a: A, b: B, al: a };
+}
+function toRgb(color) {
+  if (isRgb(color)) return color;
+  if (isHsl(color)) return _hsl2rgb(color);
+  if (isHsb(color)) return _hsb2rgb(color);
+  if (isCmyk(color)) return _cmyk2rgb(color);
+  if (isCssColor(color)) return _css2rgb(color);
+  if (isHex(color)) return _hex2rgb(color);
+  if (isXyz(color)) return _xyz2rgb(color);
+  if (isLab(color)) return _xyz2rgb(_lab2xyz(color));
+  if (isLch(color)) return _xyz2rgb(_lab2xyz(_lch2lab(color)));
+  throw new Error(`Invalid color input: ${unknownToString(color)}`);
+}
+function toXyz(color) {
+  if (isXyz(color)) return color;
+  if (isLab(color)) return _lab2xyz(color);
+  if (isLch(color)) return _lab2xyz(_lch2lab(color));
+  if (isRgb(color)) return _rgb2xyz(color);
+  if (isHsl(color)) return _rgb2xyz(_hsl2rgb(color));
+  if (isHsb(color)) return _rgb2xyz(_hsb2rgb(color));
+  if (isCmyk(color)) return _rgb2xyz(_cmyk2rgb(color));
+  if (isCssColor(color)) return _rgb2xyz(_css2rgb(color));
+  if (isHex(color)) return _rgb2xyz(_hex2rgb(color));
+  throw new Error(`Invalid color input: ${unknownToString(color)}`);
+}
+function toLab(color) {
+  if (isLab(color)) return color;
+  if (isLch(color)) return _lch2lab(color);
+  const xyzColor = toXyz(color);
+  return _xyz2lab(xyzColor);
+}
+function toLch(color) {
+  if (isLch(color)) return color;
+  const labColor = toLab(color);
+  return _lab2lch(labColor);
+}
+function toHsl(color) {
+  if (isHsl(color)) return color;
+  const rgbColor = toRgb(color);
+  return _rgb2hsl(rgbColor);
+}
+function toHsb(color) {
+  if (isHsb(color)) return color;
+  const rgbColor = toRgb(color);
+  return _rgb2hsb(rgbColor);
+}
+function toCmyk(color) {
+  if (isCmyk(color)) return color;
+  const rgbColor = toRgb(color);
+  return _rgb2cmyk(rgbColor);
+}
+function toCss(color) {
+  if (isCssColor(color)) return color;
+  const rgbColor = toRgb(color);
+  return _rgb2css(rgbColor);
+}
+function toHex(color) {
+  if (isHex(color)) return color;
+  const rgbColor = toRgb(color);
+  return _rgb2hex(rgbColor);
+}
+function viaRgb(color, transformer) {
+  const _color = color;
+  const rgb = toRgb(_color);
+  const transformedRgb = transformer(rgb);
+  if (isRgb(_color)) return transformedRgb;
+  if (isHsl(_color)) return toHsl(transformedRgb);
+  if (isHsb(_color)) return toHsb(transformedRgb);
+  if (isCmyk(_color)) return toCmyk(transformedRgb);
+  if (isXyz(_color)) return toXyz(transformedRgb);
+  if (isLab(_color)) return toLab(transformedRgb);
+  if (isLch(_color)) return toLch(transformedRgb);
+  if (isHex(_color)) return toRgb(transformedRgb);
+  if (isCssColor(_color)) return transformedRgb;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function viaHsl(color, transformer) {
+  const _color = color;
+  const hsl = toHsl(_color);
+  const transformedHsl = transformer(hsl);
+  if (isHsl(_color)) return transformedHsl;
+  if (isRgb(_color)) return toRgb(transformedHsl);
+  if (isHsb(_color)) return toHsb(transformedHsl);
+  if (isCmyk(_color)) return toCmyk(transformedHsl);
+  if (isXyz(_color)) return toXyz(transformedHsl);
+  if (isLab(_color)) return toLab(transformedHsl);
+  if (isLch(_color)) return toLch(transformedHsl);
+  if (isHex(_color)) return toHex(transformedHsl);
+  if (isCssColor(_color)) return transformedHsl;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function viaHsb(color, transformer) {
+  const _color = color;
+  const hsb = toHsb(_color);
+  const transformedHsb = transformer(hsb);
+  if (isHsb(_color)) return transformedHsb;
+  if (isRgb(_color)) return toRgb(transformedHsb);
+  if (isHsl(_color)) return toHsl(transformedHsb);
+  if (isCmyk(_color)) return toCmyk(transformedHsb);
+  if (isXyz(_color)) return toXyz(transformedHsb);
+  if (isLab(_color)) return toLab(transformedHsb);
+  if (isLch(_color)) return toLch(transformedHsb);
+  if (isHex(_color)) return toHex(transformedHsb);
+  if (isCssColor(_color)) return transformedHsb;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function viaCmyk(color, transformer) {
+  const _color = color;
+  const cmyk = toCmyk(_color);
+  const transformedCmyk = transformer(cmyk);
+  if (isHsb(_color)) return transformedCmyk;
+  if (isRgb(_color)) return toRgb(transformedCmyk);
+  if (isHsl(_color)) return toHsl(transformedCmyk);
+  if (isCmyk(_color)) return toCmyk(transformedCmyk);
+  if (isXyz(_color)) return toXyz(transformedCmyk);
+  if (isLab(_color)) return toLab(transformedCmyk);
+  if (isLch(_color)) return toLch(transformedCmyk);
+  if (isHex(_color)) return toHex(transformedCmyk);
+  if (isCssColor(_color)) return transformedCmyk;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function viaXyz(color, transformer) {
+  const _color = color;
+  const xyz = toXyz(_color);
+  const transformedXyz = transformer(xyz);
+  if (isHsb(_color)) return transformedXyz;
+  if (isRgb(_color)) return toRgb(transformedXyz);
+  if (isHsl(_color)) return toHsl(transformedXyz);
+  if (isCmyk(_color)) return toCmyk(transformedXyz);
+  if (isXyz(_color)) return toXyz(transformedXyz);
+  if (isLab(_color)) return toLab(transformedXyz);
+  if (isLch(_color)) return toLch(transformedXyz);
+  if (isHex(_color)) return toHex(transformedXyz);
+  if (isCssColor(_color)) return transformedXyz;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function viaLab(color, transformer) {
+  const _color = color;
+  const lab = toLab(_color);
+  const transformedLab = transformer(lab);
+  if (isHsb(_color)) return transformedLab;
+  if (isRgb(_color)) return toRgb(transformedLab);
+  if (isHsl(_color)) return toHsl(transformedLab);
+  if (isCmyk(_color)) return toCmyk(transformedLab);
+  if (isXyz(_color)) return toXyz(transformedLab);
+  if (isLab(_color)) return toLab(transformedLab);
+  if (isLch(_color)) return toLch(transformedLab);
+  if (isHex(_color)) return toHex(transformedLab);
+  if (isCssColor(_color)) return transformedLab;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function viaLch(color, transformer) {
+  const _color = color;
+  const lch = toLch(_color);
+  const transformedLch = transformer(lch);
+  if (isHsb(_color)) return transformedLch;
+  if (isRgb(_color)) return toRgb(transformedLch);
+  if (isHsl(_color)) return toHsl(transformedLch);
+  if (isCmyk(_color)) return toCmyk(transformedLch);
+  if (isXyz(_color)) return toXyz(transformedLch);
+  if (isLab(_color)) return toLab(transformedLch);
+  if (isLch(_color)) return toLch(transformedLch);
+  if (isHex(_color)) return toHex(transformedLch);
+  if (isCssColor(_color)) return transformedLch;
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+function linearizeToSRgb(rgb) {
+  const cleanRgb = tidy(rgb);
+  const linearChannel = (v) => {
+    const n = v / 255;
+    if (n <= 0.04045) return n / 12.92;
+    else return Math.pow((n + 0.055) / 1.055, 2.4);
+  };
+  return {
+    linearR: linearChannel(cleanRgb.r),
+    linearG: linearChannel(cleanRgb.g),
+    linearB: linearChannel(cleanRgb.b),
+    a: cleanRgb.a
+  };
+}
+function delinearizeToRgb(srgb) {
+  const gammaChannel = (v) => {
+    if (v <= 31308e-7) return v * 12.92;
+    else return 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+  };
+  return tidy({
+    r: gammaChannel(srgb.linearR) * 255,
+    g: gammaChannel(srgb.linearG) * 255,
+    b: gammaChannel(srgb.linearB) * 255,
+    a: srgb.a
+  });
+}
+
+// src/agnostic/colors/tidy/index.ts
+function tidy(color) {
+  const _color = color;
+  if (isRgb(_color)) return {
+    r: clamp(_color.r, 0, 255),
+    g: clamp(_color.g, 0, 255),
+    b: clamp(_color.b, 0, 255),
+    a: clamp(_color.a ?? 1, 0, 1)
+  };
+  if (isHsl(_color)) return {
+    h: absoluteModulo(_color.h, 360),
+    s: clamp(_color.s, 0, 100),
+    l: clamp(_color.l, 0, 100),
+    a: clamp(_color.a ?? 1, 0, 1)
+  };
+  if (isHsb(_color)) return {
+    h: absoluteModulo(_color.h, 360),
+    s: clamp(_color.s, 0, 100),
+    b: clamp(_color.b, 0, 100),
+    a: clamp(_color.a ?? 1, 0, 1)
+  };
+  if (isCmyk(_color)) return {
+    c: clamp(_color.c, 0, 100),
+    m: clamp(_color.m, 0, 100),
+    y: clamp(_color.y, 0, 100),
+    k: clamp(_color.k, 0, 100),
+    a: clamp(_color.a ?? 1, 0, 1)
+  };
+  if (isXyz(_color)) return {
+    x: _color.x,
+    y: _color.y,
+    z: _color.z,
+    a: clamp(_color.a ?? 1, 0, 1)
+  };
+  if (isLab(_color)) return {
+    l: clamp(_color.l, 0, 100),
+    a: _color.a,
+    b: _color.b,
+    al: clamp(_color.al ?? 1, 0, 1)
+  };
+  if (isLch(_color)) return {
+    l: clamp(_color.l, 0, 100),
+    c: Math.max(0, _color.c),
+    h: clamp(_color.h, 0, 360),
+    a: clamp(_color.a ?? 1, 0, 1)
+  };
+  if (isCssColor(_color)) return tidy(toRgb(_color));
+  if (isHex(_color)) return toHex(tidy(toRgb(_color)));
+  const _typecheck = true;
+  throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+
+export {
+  tidy,
+  toRgb,
+  toXyz,
+  toLab,
+  toLch,
+  toHsl,
+  toHsb,
+  toCmyk,
+  toCss,
+  toHex,
+  viaRgb,
+  viaHsl,
+  viaHsb,
+  viaCmyk,
+  viaXyz,
+  viaLab,
+  viaLch,
+  linearizeToSRgb,
+  delinearizeToRgb
+};

package/chunks/chunk-DMWGHBIL.js

@@ -0,0 +1,25 @@
+import {
+  get
+} from "./chunk-57YKZBJR.js";
+
+// src/agnostic/html/get-node-ancestors/index.ts
+function getNodeAncestors(node, traverseShadowRoots) {
+  const returned = [];
+  let currentNode = node;
+  const { ShadowRoot } = get();
+  while (currentNode !== null) {
+    returned.push(currentNode);
+    const parentNode = currentNode.parentNode;
+    if (parentNode instanceof ShadowRoot) {
+      returned.push(parentNode);
+      currentNode = traverseShadowRoots === true ? parentNode.host : null;
+      continue;
+    }
+    currentNode = currentNode.parentElement;
+  }
+  return returned;
+}
+
+export {
+  getNodeAncestors
+};

package/chunks/chunk-DNIOWD7K.js

@@ -0,0 +1,8 @@
+// src/agnostic/numbers/absolute-modulo/index.ts
+function absoluteModulo(nbr, modulo) {
+  return (nbr % modulo + modulo) % modulo;
+}
+
+export {
+  absoluteModulo
+};

package/chunks/chunk-DU6U226H.js

@@ -0,0 +1,23 @@
+import {
+  SmartTags
+} from "./chunk-FCABYQRX.js";
+import {
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+
+// src/agnostic/html/hyper-json/smart-tags/isolated/any/index.ts
+var any = SmartTags.makeSmartTag({
+  name: "any",
+  defaultMode: "isolation",
+  isolationInitType: "array",
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
+  func: (main, args) => {
+    if (args.length === 0) return makeSuccess(main);
+    return makeSuccess([main, ...args]);
+  }
+});
+
+export {
+  any
+};

package/chunks/chunk-E2ZY3SEW.js

@@ -0,0 +1,26 @@
+import {
+  linearizeToSRgb,
+  toLab,
+  toRgb,
+  toXyz
+} from "./chunk-CVMYA5XK.js";
+
+// src/agnostic/colors/luminance/index.ts
+function luminanceRgb(rgb) {
+  const { linearR, linearG, linearB } = linearizeToSRgb(rgb);
+  return 0.2126 * linearR + 0.7152 * linearG + 0.0722 * linearB;
+}
+function luminance(color, method = "lab") {
+  switch (method) {
+    case "rgb":
+      return luminanceRgb(toRgb(color));
+    case "xyz":
+      return toXyz(color).y / 100;
+    case "lab":
+      return toLab(color).l / 100;
+  }
+}
+
+export {
+  luminance
+};