origam 0.1.0

package/dist/src/utils/Commons/color.util.cjs

@@ -0,0 +1,337 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.APCAcontrast = APCAcontrast;
+exports.HSLtoHSV = HSLtoHSV;
+exports.HSLtoRGB = HSLtoRGB;
+exports.HSVtoCSS = HSVtoCSS;
+exports.HSVtoHSL = HSVtoHSL;
+exports.HSVtoHex = HSVtoHex;
+exports.HSVtoRGB = HSVtoRGB;
+exports.HexToHSV = HexToHSV;
+exports.HexToRGB = HexToRGB;
+exports.LabtoXyz = LabtoXyz;
+exports.RGBtoCSS = RGBtoCSS;
+exports.RGBtoHSV = RGBtoHSV;
+exports.RGBtoHex = RGBtoHex;
+exports.RgbtoXyz = RgbtoXyz;
+exports.XyzToRgb = XyzToRgb;
+exports.XyztoLab = XyztoLab;
+exports.classToHex = classToHex;
+exports.darken = darken;
+exports.getContrast = getContrast;
+exports.getForeground = getForeground;
+exports.getLuma = getLuma;
+exports.isCssColor = isCssColor;
+exports.isParsableColor = isParsableColor;
+exports.lighten = lighten;
+exports.parseColor = parseColor;
+exports.parseGradient = parseGradient;
+exports.parseHex = parseHex;
+exports.toHex = toHex;
+var _consts = require("@foxy/consts");
+var _utils = require("@foxy/utils");
+function isCssColor(color) {
+  return !!color && /^(#|var\(--|(rgb|hsl)a?\()/.test(color);
+}
+function isParsableColor(color) {
+  return isCssColor(color) && !/^((rgb|hsl)a?\()?var\(--/.test(color);
+}
+function parseColor(color) {
+  if (typeof color === "number") {
+    if (isNaN(color) || color < 0 || color > 16777215) {
+      (0, _utils.consoleWarn)(`'${color}' is not a valid hex color`);
+    }
+    return {
+      r: (color & 16711680) >> 16,
+      g: (color & 65280) >> 8,
+      b: color & 255
+    };
+  } else if (typeof color === "string" && _consts.CSS_COLOR_REGEX.test(color)) {
+    const {
+      groups
+    } = color.match(_consts.CSS_COLOR_REGEX);
+    const {
+      fn,
+      values
+    } = groups;
+    const realValues = values.split(/,\s*/).map(v => {
+      if (v.endsWith("%") && ["hsl", "hsla", "hsv", "hsva"].includes(fn)) {
+        return parseFloat(v) / 100;
+      } else {
+        return parseFloat(v);
+      }
+    });
+    return _consts.COLOR_MAPPERS[fn](...realValues);
+  } else if (typeof color === "string") {
+    let hex = color.startsWith("#") ? color.slice(1) : color;
+    if ([3, 4].includes(hex.length)) {
+      hex = hex.split("").map(char => char + char).join("");
+    } else if (![6, 8].includes(hex.length)) {
+      (0, _utils.consoleWarn)(`'${color}' is not a valid hex(a) color`);
+    }
+    const integer = (0, _utils.int)(hex, 16);
+    if (isNaN(integer) || integer < 0 || integer > 4294967295) {
+      (0, _utils.consoleWarn)(`'${color}' is not a valid hex(a) color`);
+    }
+    return HexToRGB(hex);
+  } else if (typeof color === "object") {
+    if ((0, _utils.has)(color, ["r", "g", "b"])) {
+      return color;
+    } else if ((0, _utils.has)(color, ["h", "s", "l"])) {
+      return HSVtoRGB(HSLtoHSV(color));
+    } else if ((0, _utils.has)(color, ["h", "s", "v"])) {
+      return HSVtoRGB(color);
+    }
+  }
+  throw new TypeError(`Invalid color: ${color == null ? color : String(color) || color.constructor.name}
+Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
+}
+function getForeground(color) {
+  const blackContrast = Math.abs(APCAcontrast(parseColor(0), parseColor(color)));
+  const whiteContrast = Math.abs(APCAcontrast(parseColor(16777215), parseColor(color)));
+  return whiteContrast > Math.min(blackContrast, 50) ? "#fff" : "#000";
+}
+function HSLtoRGB(hsla) {
+  return HSVtoRGB(HSLtoHSV(hsla));
+}
+function RGBtoHSV(rgba) {
+  if (!rgba) return {
+    h: 0,
+    s: 1,
+    v: 1,
+    a: 1
+  };
+  const r = rgba.r / 255;
+  const g = rgba.g / 255;
+  const b = rgba.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0;
+  if (max !== min) {
+    if (max === r) {
+      h = 60 * (0 + (g - b) / (max - min));
+    } else if (max === g) {
+      h = 60 * (2 + (b - r) / (max - min));
+    } else if (max === b) {
+      h = 60 * (4 + (r - g) / (max - min));
+    }
+  }
+  if (h < 0) h = h + 360;
+  const s = max === 0 ? 0 : (max - min) / max;
+  const hsv = [h, s, max];
+  return {
+    h: hsv[0],
+    s: hsv[1],
+    v: hsv[2],
+    a: rgba.a
+  };
+}
+function HSVtoHSL(hsva) {
+  const {
+    h,
+    s,
+    v,
+    a
+  } = hsva;
+  const l = v - v * s / 2;
+  const sprime = l === 1 || l === 0 ? 0 : (v - l) / Math.min(l, 1 - l);
+  return {
+    h,
+    s: sprime,
+    l,
+    a
+  };
+}
+function HSLtoHSV(hsl) {
+  const {
+    h,
+    s,
+    l,
+    a
+  } = hsl;
+  const v = l + s * Math.min(l, 1 - l);
+  const sprime = v === 0 ? 0 : 2 - 2 * l / v;
+  return {
+    h,
+    s: sprime,
+    v,
+    a
+  };
+}
+function RGBtoCSS({
+  r,
+  g,
+  b,
+  a
+}) {
+  return a === void 0 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+function HSVtoCSS(hsva) {
+  return RGBtoCSS(HSVtoRGB(hsva));
+}
+function toHex(v) {
+  const h = Math.round(v).toString(16);
+  return ("00".substr(0, 2 - h.length) + h).toUpperCase();
+}
+function RGBtoHex({
+  r,
+  g,
+  b,
+  a
+}) {
+  return `#${[toHex(r), toHex(g), toHex(b), a !== void 0 ? toHex(Math.round(a * 255)) : ""].join("")}`;
+}
+function HexToRGB(hex) {
+  hex = parseHex(hex);
+  const [r, g, b, a] = (0, _utils.chunk)(hex, 2).map(c => (0, _utils.int)(c, 16));
+  const alpha = a === void 0 ? a : a / 255;
+  return {
+    r,
+    g,
+    b,
+    a: alpha
+  };
+}
+function HexToHSV(hex) {
+  const rgb = HexToRGB(hex);
+  return RGBtoHSV(rgb);
+}
+function HSVtoHex(hsva) {
+  return RGBtoHex(HSVtoRGB(hsva));
+}
+function HSVtoRGB(hsva) {
+  const {
+    h,
+    s,
+    v,
+    a
+  } = hsva;
+  const f = n => {
+    const k = (n + h / 60) % 6;
+    return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
+  };
+  const rgb = [f(5), f(3), f(1)].map(v2 => Math.round(v2 * 255));
+  return {
+    r: rgb[0],
+    g: rgb[1],
+    b: rgb[2],
+    a
+  };
+}
+function parseHex(hex) {
+  if (hex.startsWith("#")) {
+    hex = hex.slice(1);
+  }
+  hex = hex.replace(/([^0-9a-f])/gi, "F");
+  if (hex.length === 3 || hex.length === 4) {
+    hex = hex.split("").map(x => x + x).join("");
+  }
+  if (hex.length !== 6) {
+    hex = (0, _utils.padEnd)((0, _utils.padEnd)(hex, 6), 8, "F");
+  }
+  return hex;
+}
+function lighten(value, amount) {
+  const lab = XyztoLab(RgbtoXyz(value));
+  lab[0] = lab[0] + amount * 10;
+  return XyzToRgb(LabtoXyz(lab));
+}
+function darken(value, amount) {
+  const lab = XyztoLab(RgbtoXyz(value));
+  lab[0] = lab[0] - amount * 10;
+  return XyzToRgb(LabtoXyz(lab));
+}
+function getContrast(first, second) {
+  const l1 = getLuma(first);
+  const l2 = getLuma(second);
+  const light = Math.max(l1, l2);
+  const dark = Math.min(l1, l2);
+  return (light + 0.05) / (dark + 0.05);
+}
+function getLuma(color) {
+  const rgb = parseColor(color);
+  return RgbtoXyz(rgb)[1];
+}
+function parseGradient(gradient, colors) {
+  return gradient.replace(/([a-z]+(\s[a-z]+-[1-5])?)(?=$|,)/gi, x => {
+    return classToHex(x, colors) || x;
+  }).replace(/(rgba\()#[0-9a-f]+(?=,)/gi, x => {
+    return "rgba(" + Object.values(HexToRGB(parseHex(x.replace(/rgba\(/, "")))).slice(0, 3).join(",");
+  });
+}
+function classToHex(color, colors) {
+  const [colorName, colorModifier] = color.toString().trim().replace("-", "").split(" ", 2);
+  let hexColor = "";
+  if (colorName && colorName in colors) {
+    if (colorModifier && colorModifier in colors[colorName]) {
+      hexColor = colors[colorName][colorModifier];
+    } else if ("base" in colors[colorName]) {
+      hexColor = colors[colorName].base;
+    }
+  }
+  return hexColor;
+}
+function XyzToRgb(xyz) {
+  const rgb = Array(3);
+  const transform = _consts.SRGB_FORWARD_TRANSFORM;
+  const matrix = _consts.SRGB_FORWARD_MATRIX;
+  for (let i = 0; i < 3; ++i) {
+    rgb[i] = Math.round((0, _utils.clamp)(transform(matrix[i][0] * xyz[0] + matrix[i][1] * xyz[1] + matrix[i][2] * xyz[2])) * 255);
+  }
+  return {
+    r: rgb[0],
+    g: rgb[1],
+    b: rgb[2]
+  };
+}
+function RgbtoXyz({
+  r,
+  g,
+  b
+}) {
+  const xyz = [0, 0, 0];
+  const transform = _consts.SRGB_REVERSE_TRANSFORM;
+  const matrix = _consts.SRGB_REVERSE_MATRIX;
+  const rLinear = transform(r / 255);
+  const gLinear = transform(g / 255);
+  const bLinear = transform(b / 255);
+  for (let i = 0; i < 3; ++i) {
+    xyz[i] = matrix[i][0] * rLinear + matrix[i][1] * gLinear + matrix[i][2] * bLinear;
+  }
+  return xyz;
+}
+function XyztoLab(xyz) {
+  const transform = _consts.CIELAB_FORWARD_TRANSFORM;
+  const transformedY = transform(xyz[1]);
+  return [116 * transformedY - 16, 500 * (transform(xyz[0] / 0.95047) - transformedY), 200 * (transformedY - transform(xyz[2] / 1.08883))];
+}
+function LabtoXyz(lab) {
+  const transform = _consts.CIELAB_REVERSE_TRANSFORM;
+  const Ln = (lab[0] + 16) / 116;
+  return [transform(Ln + lab[1] / 500) * 0.95047, transform(Ln), transform(Ln - lab[2] / 200) * 1.08883];
+}
+function APCAcontrast(text, background) {
+  const Rtxt = (text.r / 255) ** _consts.MAIN_TRC;
+  const Gtxt = (text.g / 255) ** _consts.MAIN_TRC;
+  const Btxt = (text.b / 255) ** _consts.MAIN_TRC;
+  const Rbg = (background.r / 255) ** _consts.MAIN_TRC;
+  const Gbg = (background.g / 255) ** _consts.MAIN_TRC;
+  const Bbg = (background.b / 255) ** _consts.MAIN_TRC;
+  let Ytxt = Rtxt * _consts.RCO + Gtxt * _consts.GCO + Btxt * _consts.BCO;
+  let Ybg = Rbg * _consts.RCO + Gbg * _consts.GCO + Bbg * _consts.BCO;
+  if (Ytxt <= _consts.BLK_THRS) Ytxt += (_consts.BLK_THRS - Ytxt) ** _consts.BLK_CLMP;
+  if (Ybg <= _consts.BLK_THRS) Ybg += (_consts.BLK_THRS - Ybg) ** _consts.BLK_CLMP;
+  if (Math.abs(Ybg - Ytxt) < _consts.COLOR_DELTA_Y_MIN) return 0;
+  let outputContrast;
+  if (Ybg > Ytxt) {
+    const SAPC = (Ybg ** _consts.NORM_BG - Ytxt ** _consts.NORM_TXT) * _consts.SCALE_B_O_W;
+    outputContrast = SAPC < _consts.LO_CLIP ? 0 : SAPC < _consts.LO_CON_THRESH ? SAPC - SAPC * _consts.LO_CON_FACTOR * _consts.LO_CON_OFFSET : SAPC - _consts.LO_CON_OFFSET;
+  } else {
+    const SAPC = (Ybg ** _consts.REV_BG - Ytxt ** _consts.REV_TXT) * _consts.SCALE_W_O_B;
+    outputContrast = SAPC > -_consts.LO_CLIP ? 0 : SAPC > -_consts.LO_CON_THRESH ? SAPC - SAPC * _consts.LO_CON_FACTOR * _consts.LO_CON_OFFSET : SAPC + _consts.LO_CON_OFFSET;
+  }
+  return outputContrast * 100;
+}

package/dist/src/utils/Commons/color.util.d.ts

@@ -0,0 +1,29 @@
+import type { TColorType, THex, THSLA, THSVA, TLAB, TRGBA, TXYZ } from '@foxy/types';
+export declare function isCssColor(color?: string | null | false): boolean;
+export declare function isParsableColor(color: string): boolean;
+export declare function parseColor(color: TColorType): TRGBA;
+export declare function getForeground(color: TColorType): "#fff" | "#000";
+export declare function HSLtoRGB(hsla: THSLA): TRGBA;
+export declare function RGBtoHSV(rgba: TRGBA): THSVA;
+export declare function HSVtoHSL(hsva: THSVA): THSLA;
+export declare function HSLtoHSV(hsl: THSLA): THSVA;
+export declare function RGBtoCSS({ r, g, b, a }: TRGBA): string;
+export declare function HSVtoCSS(hsva: THSVA): string;
+export declare function toHex(v: number): string;
+export declare function RGBtoHex({ r, g, b, a }: TRGBA): THex;
+export declare function HexToRGB(hex: THex): TRGBA;
+export declare function HexToHSV(hex: THex): THSVA;
+export declare function HSVtoHex(hsva: THSVA): THex;
+export declare function HSVtoRGB(hsva: THSVA): TRGBA;
+export declare function parseHex(hex: string): THex;
+export declare function lighten(value: TRGBA, amount: number): TRGBA;
+export declare function darken(value: TRGBA, amount: number): TRGBA;
+export declare function getContrast(first: TColorType, second: TColorType): number;
+export declare function getLuma(color: TColorType): TXYZ;
+export declare function parseGradient(gradient: string, colors: Record<string, Record<string, string>>): string;
+export declare function classToHex(color: string, colors: Record<string, Record<string, string>>): string;
+export declare function XyzToRgb(xyz: TXYZ): TRGBA;
+export declare function RgbtoXyz({ r, g, b }: TRGBA): TXYZ;
+export declare function XyztoLab(xyz: TXYZ): TLAB;
+export declare function LabtoXyz(lab: TLAB): TXYZ;
+export declare function APCAcontrast(text: TRGBA, background: TRGBA): number;

package/dist/src/utils/Commons/color.util.js

@@ -0,0 +1,281 @@
+import {
+  BCO,
+  BLK_CLMP,
+  BLK_THRS,
+  CIELAB_FORWARD_TRANSFORM,
+  CIELAB_REVERSE_TRANSFORM,
+  COLOR_DELTA_Y_MIN,
+  COLOR_MAPPERS,
+  CSS_COLOR_REGEX,
+  GCO,
+  LO_CLIP,
+  LO_CON_FACTOR,
+  LO_CON_OFFSET,
+  LO_CON_THRESH,
+  MAIN_TRC,
+  NORM_BG,
+  NORM_TXT,
+  RCO,
+  REV_BG,
+  REV_TXT,
+  SCALE_B_O_W,
+  SCALE_W_O_B,
+  SRGB_FORWARD_MATRIX,
+  SRGB_FORWARD_TRANSFORM,
+  SRGB_REVERSE_MATRIX,
+  SRGB_REVERSE_TRANSFORM
+} from "@foxy/consts";
+import { chunk, clamp, consoleWarn, has, int, padEnd } from "@foxy/utils";
+export function isCssColor(color) {
+  return !!color && /^(#|var\(--|(rgb|hsl)a?\()/.test(color);
+}
+export function isParsableColor(color) {
+  return isCssColor(color) && !/^((rgb|hsl)a?\()?var\(--/.test(color);
+}
+export function parseColor(color) {
+  if (typeof color === "number") {
+    if (isNaN(color) || color < 0 || color > 16777215) {
+      consoleWarn(`'${color}' is not a valid hex color`);
+    }
+    return {
+      r: (color & 16711680) >> 16,
+      g: (color & 65280) >> 8,
+      b: color & 255
+    };
+  } else if (typeof color === "string" && CSS_COLOR_REGEX.test(color)) {
+    const { groups } = color.match(CSS_COLOR_REGEX);
+    const { fn, values } = groups;
+    const realValues = values.split(/,\s*/).map((v) => {
+      if (v.endsWith("%") && ["hsl", "hsla", "hsv", "hsva"].includes(fn)) {
+        return parseFloat(v) / 100;
+      } else {
+        return parseFloat(v);
+      }
+    });
+    return COLOR_MAPPERS[fn](...realValues);
+  } else if (typeof color === "string") {
+    let hex = color.startsWith("#") ? color.slice(1) : color;
+    if ([3, 4].includes(hex.length)) {
+      hex = hex.split("").map((char) => char + char).join("");
+    } else if (![6, 8].includes(hex.length)) {
+      consoleWarn(`'${color}' is not a valid hex(a) color`);
+    }
+    const integer = int(hex, 16);
+    if (isNaN(integer) || integer < 0 || integer > 4294967295) {
+      consoleWarn(`'${color}' is not a valid hex(a) color`);
+    }
+    return HexToRGB(hex);
+  } else if (typeof color === "object") {
+    if (has(color, ["r", "g", "b"])) {
+      return color;
+    } else if (has(color, ["h", "s", "l"])) {
+      return HSVtoRGB(HSLtoHSV(color));
+    } else if (has(color, ["h", "s", "v"])) {
+      return HSVtoRGB(color);
+    }
+  }
+  throw new TypeError(`Invalid color: ${color == null ? color : String(color) || color.constructor.name}
+Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
+}
+export function getForeground(color) {
+  const blackContrast = Math.abs(APCAcontrast(parseColor(0), parseColor(color)));
+  const whiteContrast = Math.abs(APCAcontrast(parseColor(16777215), parseColor(color)));
+  return whiteContrast > Math.min(blackContrast, 50) ? "#fff" : "#000";
+}
+export function HSLtoRGB(hsla) {
+  return HSVtoRGB(HSLtoHSV(hsla));
+}
+export function RGBtoHSV(rgba) {
+  if (!rgba) return { h: 0, s: 1, v: 1, a: 1 };
+  const r = rgba.r / 255;
+  const g = rgba.g / 255;
+  const b = rgba.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0;
+  if (max !== min) {
+    if (max === r) {
+      h = 60 * (0 + (g - b) / (max - min));
+    } else if (max === g) {
+      h = 60 * (2 + (b - r) / (max - min));
+    } else if (max === b) {
+      h = 60 * (4 + (r - g) / (max - min));
+    }
+  }
+  if (h < 0) h = h + 360;
+  const s = max === 0 ? 0 : (max - min) / max;
+  const hsv = [h, s, max];
+  return { h: hsv[0], s: hsv[1], v: hsv[2], a: rgba.a };
+}
+export function HSVtoHSL(hsva) {
+  const { h, s, v, a } = hsva;
+  const l = v - v * s / 2;
+  const sprime = l === 1 || l === 0 ? 0 : (v - l) / Math.min(l, 1 - l);
+  return { h, s: sprime, l, a };
+}
+export function HSLtoHSV(hsl) {
+  const { h, s, l, a } = hsl;
+  const v = l + s * Math.min(l, 1 - l);
+  const sprime = v === 0 ? 0 : 2 - 2 * l / v;
+  return { h, s: sprime, v, a };
+}
+export function RGBtoCSS({ r, g, b, a }) {
+  return a === void 0 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+export function HSVtoCSS(hsva) {
+  return RGBtoCSS(HSVtoRGB(hsva));
+}
+export function toHex(v) {
+  const h = Math.round(v).toString(16);
+  return ("00".substr(0, 2 - h.length) + h).toUpperCase();
+}
+export function RGBtoHex({ r, g, b, a }) {
+  return `#${[
+    toHex(r),
+    toHex(g),
+    toHex(b),
+    a !== void 0 ? toHex(Math.round(a * 255)) : ""
+  ].join("")}`;
+}
+export function HexToRGB(hex) {
+  hex = parseHex(hex);
+  const [r, g, b, a] = chunk(hex, 2).map((c) => int(c, 16));
+  const alpha = a === void 0 ? a : a / 255;
+  return { r, g, b, a: alpha };
+}
+export function HexToHSV(hex) {
+  const rgb = HexToRGB(hex);
+  return RGBtoHSV(rgb);
+}
+export function HSVtoHex(hsva) {
+  return RGBtoHex(HSVtoRGB(hsva));
+}
+export function HSVtoRGB(hsva) {
+  const { h, s, v, a } = hsva;
+  const f = (n) => {
+    const k = (n + h / 60) % 6;
+    return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
+  };
+  const rgb = [f(5), f(3), f(1)].map((v2) => Math.round(v2 * 255));
+  return { r: rgb[0], g: rgb[1], b: rgb[2], a };
+}
+export function parseHex(hex) {
+  if (hex.startsWith("#")) {
+    hex = hex.slice(1);
+  }
+  hex = hex.replace(/([^0-9a-f])/gi, "F");
+  if (hex.length === 3 || hex.length === 4) {
+    hex = hex.split("").map((x) => x + x).join("");
+  }
+  if (hex.length !== 6) {
+    hex = padEnd(padEnd(hex, 6), 8, "F");
+  }
+  return hex;
+}
+export function lighten(value, amount) {
+  const lab = XyztoLab(RgbtoXyz(value));
+  lab[0] = lab[0] + amount * 10;
+  return XyzToRgb(LabtoXyz(lab));
+}
+export function darken(value, amount) {
+  const lab = XyztoLab(RgbtoXyz(value));
+  lab[0] = lab[0] - amount * 10;
+  return XyzToRgb(LabtoXyz(lab));
+}
+export function getContrast(first, second) {
+  const l1 = getLuma(first);
+  const l2 = getLuma(second);
+  const light = Math.max(l1, l2);
+  const dark = Math.min(l1, l2);
+  return (light + 0.05) / (dark + 0.05);
+}
+export function getLuma(color) {
+  const rgb = parseColor(color);
+  return RgbtoXyz(rgb)[1];
+}
+export function parseGradient(gradient, colors) {
+  return gradient.replace(/([a-z]+(\s[a-z]+-[1-5])?)(?=$|,)/gi, (x) => {
+    return classToHex(x, colors) || x;
+  }).replace(/(rgba\()#[0-9a-f]+(?=,)/gi, (x) => {
+    return "rgba(" + Object.values(HexToRGB(parseHex(x.replace(/rgba\(/, "")))).slice(0, 3).join(",");
+  });
+}
+export function classToHex(color, colors) {
+  const [colorName, colorModifier] = color.toString().trim().replace("-", "").split(" ", 2);
+  let hexColor = "";
+  if (colorName && colorName in colors) {
+    if (colorModifier && colorModifier in colors[colorName]) {
+      hexColor = colors[colorName][colorModifier];
+    } else if ("base" in colors[colorName]) {
+      hexColor = colors[colorName].base;
+    }
+  }
+  return hexColor;
+}
+export function XyzToRgb(xyz) {
+  const rgb = Array(3);
+  const transform = SRGB_FORWARD_TRANSFORM;
+  const matrix = SRGB_FORWARD_MATRIX;
+  for (let i = 0; i < 3; ++i) {
+    rgb[i] = Math.round(clamp(transform(
+      matrix[i][0] * xyz[0] + matrix[i][1] * xyz[1] + matrix[i][2] * xyz[2]
+    )) * 255);
+  }
+  return {
+    r: rgb[0],
+    g: rgb[1],
+    b: rgb[2]
+  };
+}
+export function RgbtoXyz({ r, g, b }) {
+  const xyz = [0, 0, 0];
+  const transform = SRGB_REVERSE_TRANSFORM;
+  const matrix = SRGB_REVERSE_MATRIX;
+  const rLinear = transform(r / 255);
+  const gLinear = transform(g / 255);
+  const bLinear = transform(b / 255);
+  for (let i = 0; i < 3; ++i) {
+    xyz[i] = matrix[i][0] * rLinear + matrix[i][1] * gLinear + matrix[i][2] * bLinear;
+  }
+  return xyz;
+}
+export function XyztoLab(xyz) {
+  const transform = CIELAB_FORWARD_TRANSFORM;
+  const transformedY = transform(xyz[1]);
+  return [
+    116 * transformedY - 16,
+    500 * (transform(xyz[0] / 0.95047) - transformedY),
+    200 * (transformedY - transform(xyz[2] / 1.08883))
+  ];
+}
+export function LabtoXyz(lab) {
+  const transform = CIELAB_REVERSE_TRANSFORM;
+  const Ln = (lab[0] + 16) / 116;
+  return [
+    transform(Ln + lab[1] / 500) * 0.95047,
+    transform(Ln),
+    transform(Ln - lab[2] / 200) * 1.08883
+  ];
+}
+export function APCAcontrast(text, background) {
+  const Rtxt = (text.r / 255) ** MAIN_TRC;
+  const Gtxt = (text.g / 255) ** MAIN_TRC;
+  const Btxt = (text.b / 255) ** MAIN_TRC;
+  const Rbg = (background.r / 255) ** MAIN_TRC;
+  const Gbg = (background.g / 255) ** MAIN_TRC;
+  const Bbg = (background.b / 255) ** MAIN_TRC;
+  let Ytxt = Rtxt * RCO + Gtxt * GCO + Btxt * BCO;
+  let Ybg = Rbg * RCO + Gbg * GCO + Bbg * BCO;
+  if (Ytxt <= BLK_THRS) Ytxt += (BLK_THRS - Ytxt) ** BLK_CLMP;
+  if (Ybg <= BLK_THRS) Ybg += (BLK_THRS - Ybg) ** BLK_CLMP;
+  if (Math.abs(Ybg - Ytxt) < COLOR_DELTA_Y_MIN) return 0;
+  let outputContrast;
+  if (Ybg > Ytxt) {
+    const SAPC = (Ybg ** NORM_BG - Ytxt ** NORM_TXT) * SCALE_B_O_W;
+    outputContrast = SAPC < LO_CLIP ? 0 : SAPC < LO_CON_THRESH ? SAPC - SAPC * LO_CON_FACTOR * LO_CON_OFFSET : SAPC - LO_CON_OFFSET;
+  } else {
+    const SAPC = (Ybg ** REV_BG - Ytxt ** REV_TXT) * SCALE_W_O_B;
+    outputContrast = SAPC > -LO_CLIP ? 0 : SAPC > -LO_CON_THRESH ? SAPC - SAPC * LO_CON_FACTOR * LO_CON_OFFSET : SAPC + LO_CON_OFFSET;
+  }
+  return outputContrast * 100;
+}