phondropoulos/smatchit_tailwind_project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
smatchit_tailwind_project/node_modules/culori/bundled/culori.js
phondropoulos 2f7b948cda First Commit
2024-07-15 15:57:41 +03:00

4790 lines
136 KiB
JavaScript
Raw Permalink Blame History

var culori = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
// src/index.js
var src_exports = {};
__export(src_exports, {
a98: () => a98,
average: () => average,
averageAngle: () => averageAngle,
averageNumber: () => averageNumber,
blend: () => blend_default,
blerp: () => blerp,
clampChroma: () => clampChroma,
clampGamut: () => clampGamut,
clampRgb: () => clampRgb,
colorsNamed: () => named_default,
convertA98ToXyz65: () => convertA98ToXyz65_default,
convertCubehelixToRgb: () => convertCubehelixToRgb_default,
convertDlchToLab65: () => convertDlchToLab65_default,
convertHsiToRgb: () => convertHsiToRgb,
convertHslToRgb: () => convertHslToRgb,
convertHsvToRgb: () => convertHsvToRgb,
convertHwbToRgb: () => convertHwbToRgb,
convertJabToJch: () => convertJabToJch_default,
convertJabToRgb: () => convertJabToRgb_default,
convertJabToXyz65: () => convertJabToXyz65_default,
convertJchToJab: () => convertJchToJab_default,
convertLab65ToDlch: () => convertLab65ToDlch_default,
convertLab65ToRgb: () => convertLab65ToRgb_default,
convertLab65ToXyz65: () => convertLab65ToXyz65_default,
convertLabToLch: () => convertLabToLch_default,
convertLabToRgb: () => convertLabToRgb_default,
convertLabToXyz50: () => convertLabToXyz50_default,
convertLchToLab: () => convertLchToLab_default,
convertLchuvToLuv: () => convertLchuvToLuv_default,
convertLrgbToOklab: () => convertLrgbToOklab_default,
convertLrgbToRgb: () => convertLrgbToRgb_default,
convertLuvToLchuv: () => convertLuvToLchuv_default,
convertLuvToXyz50: () => convertLuvToXyz50_default,
convertOkhslToOklab: () => convertOkhslToOklab,
convertOkhsvToOklab: () => convertOkhsvToOklab,
convertOklabToLrgb: () => convertOklabToLrgb_default,
convertOklabToOkhsl: () => convertOklabToOkhsl,
convertOklabToOkhsv: () => convertOklabToOkhsv,
convertOklabToRgb: () => convertOklabToRgb_default,
convertP3ToXyz65: () => convertP3ToXyz65_default,
convertProphotoToXyz50: () => convertProphotoToXyz50_default,
convertRec2020ToXyz65: () => convertRec2020ToXyz65_default,
convertRgbToCubehelix: () => convertRgbToCubehelix_default,
convertRgbToHsi: () => convertRgbToHsi,
convertRgbToHsl: () => convertRgbToHsl,
convertRgbToHsv: () => convertRgbToHsv,
convertRgbToHwb: () => convertRgbToHwb,
convertRgbToJab: () => convertRgbToJab_default,
convertRgbToLab: () => convertRgbToLab_default,
convertRgbToLab65: () => convertRgbToLab65_default,
convertRgbToLrgb: () => convertRgbToLrgb_default,
convertRgbToOklab: () => convertRgbToOklab_default,
convertRgbToXyb: () => convertRgbToXyb_default,
convertRgbToXyz50: () => convertRgbToXyz50_default,
convertRgbToXyz65: () => convertRgbToXyz65_default,
convertRgbToYiq: () => convertRgbToYiq_default,
convertXybToRgb: () => convertXybToRgb_default,
convertXyz50ToLab: () => convertXyz50ToLab_default,
convertXyz50ToLuv: () => convertXyz50ToLuv_default,
convertXyz50ToProphoto: () => convertXyz50ToProphoto_default,
convertXyz50ToRgb: () => convertXyz50ToRgb_default,
convertXyz50ToXyz65: () => convertXyz50ToXyz65_default,
convertXyz65ToA98: () => convertXyz65ToA98_default,
convertXyz65ToJab: () => convertXyz65ToJab_default,
convertXyz65ToLab65: () => convertXyz65ToLab65_default,
convertXyz65ToP3: () => convertXyz65ToP3_default,
convertXyz65ToRec2020: () => convertXyz65ToRec2020_default,
convertXyz65ToRgb: () => convertXyz65ToRgb_default,
convertXyz65ToXyz50: () => convertXyz65ToXyz50_default,
convertYiqToRgb: () => convertYiqToRgb_default,
converter: () => converter_default,
cubehelix: () => cubehelix,
differenceCie76: () => differenceCie76,
differenceCie94: () => differenceCie94,
differenceCiede2000: () => differenceCiede2000,
differenceCmc: () => differenceCmc,
differenceEuclidean: () => differenceEuclidean,
differenceHueChroma: () => differenceHueChroma,
differenceHueNaive: () => differenceHueNaive,
differenceHueSaturation: () => differenceHueSaturation,
differenceHyab: () => differenceHyab,
differenceKotsarenkoRamos: () => differenceKotsarenkoRamos,
displayable: () => displayable,
dlab: () => dlab,
dlch: () => dlch,
easingGamma: () => gamma_default,
easingInOutSine: () => inOutSine_default,
easingMidpoint: () => midpoint_default,
easingSmootherstep: () => smootherstep_default,
easingSmoothstep: () => easingSmoothstep,
easingSmoothstepInverse: () => easingSmoothstepInverse,
filterBrightness: () => filterBrightness,
filterContrast: () => filterContrast,
filterDeficiencyDeuter: () => filterDeficiencyDeuter,
filterDeficiencyProt: () => filterDeficiencyProt,
filterDeficiencyTrit: () => filterDeficiencyTrit,
filterGrayscale: () => filterGrayscale,
filterHueRotate: () => filterHueRotate,
filterInvert: () => filterInvert,
filterSaturate: () => filterSaturate,
filterSepia: () => filterSepia,
fixupAlpha: () => fixupAlpha,
fixupHueDecreasing: () => fixupHueDecreasing,
fixupHueIncreasing: () => fixupHueIncreasing,
fixupHueLonger: () => fixupHueLonger,
fixupHueShorter: () => fixupHueShorter,
formatCss: () => formatCss,
formatHex: () => formatHex,
formatHex8: () => formatHex8,
formatHsl: () => formatHsl,
formatRgb: () => formatRgb,
getMode: () => getMode,
hsi: () => hsi,
hsl: () => hsl,
hsv: () => hsv,
hwb: () => hwb,
inGamut: () => inGamut,
interpolate: () => interpolate,
interpolateWith: () => interpolateWith,
interpolateWithPremultipliedAlpha: () => interpolateWithPremultipliedAlpha,
interpolatorLinear: () => interpolatorLinear,
interpolatorPiecewise: () => interpolatorPiecewise,
interpolatorSplineBasis: () => interpolatorSplineBasis,
interpolatorSplineBasisClosed: () => interpolatorSplineBasisClosed,
interpolatorSplineMonotone: () => interpolatorSplineMonotone,
interpolatorSplineMonotone2: () => interpolatorSplineMonotone2,
interpolatorSplineMonotoneClosed: () => interpolatorSplineMonotoneClosed,
interpolatorSplineNatural: () => interpolatorSplineNatural,
interpolatorSplineNaturalClosed: () => interpolatorSplineNaturalClosed,
jab: () => jab,
jch: () => jch,
lab: () => lab,
lab65: () => lab65,
lch: () => lch,
lch65: () => lch65,
lchuv: () => lchuv,
lerp: () => lerp,
lrgb: () => lrgb,
luv: () => luv,
mapAlphaDivide: () => mapAlphaDivide,
mapAlphaMultiply: () => mapAlphaMultiply,
mapTransferGamma: () => mapTransferGamma,
mapTransferLinear: () => mapTransferLinear,
mapper: () => mapper,
modeA98: () => definition_default2,
modeCubehelix: () => definition_default3,
modeDlab: () => definition_default4,
modeDlch: () => definition_default5,
modeHsi: () => definition_default6,
modeHsl: () => definition_default7,
modeHsv: () => definition_default8,
modeHwb: () => definition_default9,
modeJab: () => definition_default10,
modeJch: () => definition_default11,
modeLab: () => definition_default12,
modeLab65: () => definition_default13,
modeLch: () => definition_default14,
modeLch65: () => definition_default15,
modeLchuv: () => definition_default16,
modeLrgb: () => definition_default17,
modeLuv: () => definition_default18,
modeOkhsl: () => modeOkhsl_default,
modeOkhsv: () => modeOkhsv_default,
modeOklab: () => definition_default19,
modeOklch: () => definition_default20,
modeP3: () => definition_default21,
modeProphoto: () => definition_default22,
modeRec2020: () => definition_default23,
modeRgb: () => definition_default,
modeXyb: () => definition_default24,
modeXyz50: () => definition_default25,
modeXyz65: () => definition_default26,
modeYiq: () => definition_default27,
nearest: () => nearest_default,
okhsl: () => okhsl,
okhsv: () => okhsv,
oklab: () => oklab,
oklch: () => oklch,
p3: () => p3,
parse: () => parse_default,
parseHex: () => parseHex_default,
parseHsl: () => parseHsl_default,
parseHslLegacy: () => parseHslLegacy_default,
parseHwb: () => parseHwb_default,
parseLab: () => parseLab_default,
parseLch: () => parseLch_default,
parseNamed: () => parseNamed_default,
parseOklab: () => parseOklab_default,
parseOklch: () => parseOklch_default,
parseRgb: () => parseRgb_default,
parseRgbLegacy: () => parseRgbLegacy_default,
parseTransparent: () => parseTransparent_default,
prophoto: () => prophoto,
random: () => random_default,
rec2020: () => rec2020,
removeParser: () => removeParser,
rgb: () => rgb3,
round: () => round_default,
samples: () => samples_default,
serializeHex: () => serializeHex,
serializeHex8: () => serializeHex8,
serializeHsl: () => serializeHsl,
serializeRgb: () => serializeRgb,
toGamut: () => toGamut,
trilerp: () => trilerp,
unlerp: () => unlerp,
useMode: () => useMode,
useParser: () => useParser,
wcagContrast: () => contrast,
wcagLuminance: () => luminance,
xyb: () => xyb,
xyz50: () => xyz50,
xyz65: () => xyz65,
yiq: () => yiq
});
// src/rgb/parseNumber.js
var parseNumber = (color, len) => {
if (typeof color !== "number")
return;
if (len === 3) {
return {
mode: "rgb",
r: (color >> 8 & 15 | color >> 4 & 240) / 255,
g: (color >> 4 & 15 | color & 240) / 255,
b: (color & 15 | color << 4 & 240) / 255
};
}
if (len === 4) {
return {
mode: "rgb",
r: (color >> 12 & 15 | color >> 8 & 240) / 255,
g: (color >> 8 & 15 | color >> 4 & 240) / 255,
b: (color >> 4 & 15 | color & 240) / 255,
alpha: (color & 15 | color << 4 & 240) / 255
};
}
if (len === 6) {
return {
mode: "rgb",
r: (color >> 16 & 255) / 255,
g: (color >> 8 & 255) / 255,
b: (color & 255) / 255
};
}
if (len === 8) {
return {
mode: "rgb",
r: (color >> 24 & 255) / 255,
g: (color >> 16 & 255) / 255,
b: (color >> 8 & 255) / 255,
alpha: (color & 255) / 255
};
}
};
var parseNumber_default = parseNumber;
// src/colors/named.js
var named = {
aliceblue: 15792383,
antiquewhite: 16444375,
aqua: 65535,
aquamarine: 8388564,
azure: 15794175,
beige: 16119260,
bisque: 16770244,
black: 0,
blanchedalmond: 16772045,
blue: 255,
blueviolet: 9055202,
brown: 10824234,
burlywood: 14596231,
cadetblue: 6266528,
chartreuse: 8388352,
chocolate: 13789470,
coral: 16744272,
cornflowerblue: 6591981,
cornsilk: 16775388,
crimson: 14423100,
cyan: 65535,
darkblue: 139,
darkcyan: 35723,
darkgoldenrod: 12092939,
darkgray: 11119017,
darkgreen: 25600,
darkgrey: 11119017,
darkkhaki: 12433259,
darkmagenta: 9109643,
darkolivegreen: 5597999,
darkorange: 16747520,
darkorchid: 10040012,
darkred: 9109504,
darksalmon: 15308410,
darkseagreen: 9419919,
darkslateblue: 4734347,
darkslategray: 3100495,
darkslategrey: 3100495,
darkturquoise: 52945,
darkviolet: 9699539,
deeppink: 16716947,
deepskyblue: 49151,
dimgray: 6908265,
dimgrey: 6908265,
dodgerblue: 2003199,
firebrick: 11674146,
floralwhite: 16775920,
forestgreen: 2263842,
fuchsia: 16711935,
gainsboro: 14474460,
ghostwhite: 16316671,
gold: 16766720,
goldenrod: 14329120,
gray: 8421504,
green: 32768,
greenyellow: 11403055,
grey: 8421504,
honeydew: 15794160,
hotpink: 16738740,
indianred: 13458524,
indigo: 4915330,
ivory: 16777200,
khaki: 15787660,
lavender: 15132410,
lavenderblush: 16773365,
lawngreen: 8190976,
lemonchiffon: 16775885,
lightblue: 11393254,
lightcoral: 15761536,
lightcyan: 14745599,
lightgoldenrodyellow: 16448210,
lightgray: 13882323,
lightgreen: 9498256,
lightgrey: 13882323,
lightpink: 16758465,
lightsalmon: 16752762,
lightseagreen: 2142890,
lightskyblue: 8900346,
lightslategray: 7833753,
lightslategrey: 7833753,
lightsteelblue: 11584734,
lightyellow: 16777184,
lime: 65280,
limegreen: 3329330,
linen: 16445670,
magenta: 16711935,
maroon: 8388608,
mediumaquamarine: 6737322,
mediumblue: 205,
mediumorchid: 12211667,
mediumpurple: 9662683,
mediumseagreen: 3978097,
mediumslateblue: 8087790,
mediumspringgreen: 64154,
mediumturquoise: 4772300,
mediumvioletred: 13047173,
midnightblue: 1644912,
mintcream: 16121850,
mistyrose: 16770273,
moccasin: 16770229,
navajowhite: 16768685,
navy: 128,
oldlace: 16643558,
olive: 8421376,
olivedrab: 7048739,
orange: 16753920,
orangered: 16729344,
orchid: 14315734,
palegoldenrod: 15657130,
palegreen: 10025880,
paleturquoise: 11529966,
palevioletred: 14381203,
papayawhip: 16773077,
peachpuff: 16767673,
peru: 13468991,
pink: 16761035,
plum: 14524637,
powderblue: 11591910,
purple: 8388736,
// Added in CSS Colors Level 4:
// https://drafts.csswg.org/css-color/#changes-from-3
rebeccapurple: 6697881,
red: 16711680,
rosybrown: 12357519,
royalblue: 4286945,
saddlebrown: 9127187,
salmon: 16416882,
sandybrown: 16032864,
seagreen: 3050327,
seashell: 16774638,
sienna: 10506797,
silver: 12632256,
skyblue: 8900331,
slateblue: 6970061,
slategray: 7372944,
slategrey: 7372944,
snow: 16775930,
springgreen: 65407,
steelblue: 4620980,
tan: 13808780,
teal: 32896,
thistle: 14204888,
tomato: 16737095,
turquoise: 4251856,
violet: 15631086,
wheat: 16113331,
white: 16777215,
whitesmoke: 16119285,
yellow: 16776960,
yellowgreen: 10145074
};
var named_default = named;
// src/rgb/parseNamed.js
var parseNamed = (color) => {
return parseNumber_default(named_default[color.toLowerCase()], 6);
};
var parseNamed_default = parseNamed;
// src/rgb/parseHex.js
var hex = /^#?([0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{4}|[0-9a-f]{3})$/i;
var parseHex = (color) => {
let match;
return (match = color.match(hex)) ? parseNumber_default(parseInt(match[1], 16), match[1].length) : void 0;
};
var parseHex_default = parseHex;
// src/util/regex.js
var num = "([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)";
var num_none = `(?:${num}|none)`;
var per = `${num}%`;
var per_none = `(?:${num}%|none)`;
var num_per = `(?:${num}%|${num})`;
var num_per_none = `(?:${num}%|${num}|none)`;
var hue = `(?:${num}(deg|grad|rad|turn)|${num})`;
var hue_none = `(?:${num}(deg|grad|rad|turn)|${num}|none)`;
var c = `\\s*,\\s*`;
var rx_num_per_none = new RegExp("^" + num_per_none + "$");
// src/rgb/parseRgbLegacy.js
var rgb_num_old = new RegExp(
`^rgba?\\(\\s*${num}${c}${num}${c}${num}\\s*(?:,\\s*${num_per}\\s*)?\\)$`
);
var rgb_per_old = new RegExp(
`^rgba?\\(\\s*${per}${c}${per}${c}${per}\\s*(?:,\\s*${num_per}\\s*)?\\)$`
);
var parseRgbLegacy = (color) => {
let res = { mode: "rgb" };
let match;
if (match = color.match(rgb_num_old)) {
if (match[1] !== void 0) {
res.r = match[1] / 255;
}
if (match[2] !== void 0) {
res.g = match[2] / 255;
}
if (match[3] !== void 0) {
res.b = match[3] / 255;
}
} else if (match = color.match(rgb_per_old)) {
if (match[1] !== void 0) {
res.r = match[1] / 100;
}
if (match[2] !== void 0) {
res.g = match[2] / 100;
}
if (match[3] !== void 0) {
res.b = match[3] / 100;
}
} else {
return void 0;
}
if (match[4] !== void 0) {
res.alpha = match[4] / 100;
} else if (match[5] !== void 0) {
res.alpha = +match[5];
}
return res;
};
var parseRgbLegacy_default = parseRgbLegacy;
// src/_prepare.js
var prepare = (color, mode) => color === void 0 ? void 0 : typeof color !== "object" ? parse_default(color) : color.mode !== void 0 ? color : mode ? { ...color, mode } : void 0;
var prepare_default = prepare;
// src/converter.js
var converter = (target_mode = "rgb") => (color) => (color = prepare_default(color, target_mode)) !== void 0 ? (
// if the color's mode corresponds to our target mode
color.mode === target_mode ? (
// then just return the color
color
) : (
// otherwise check to see if we have a dedicated
// converter for the target mode
converters[color.mode][target_mode] ? (
// and return its result...
converters[color.mode][target_mode](color)
) : (
// ...otherwise pass through RGB as an intermediary step.
// if the target mode is RGB...
target_mode === "rgb" ? (
// just return the RGB
converters[color.mode].rgb(color)
) : (
// otherwise convert color.mode -> RGB -> target_mode
converters.rgb[target_mode](converters[color.mode].rgb(color))
)
)
)
) : void 0;
var converter_default = converter;
// src/modes.js
var converters = {};
var modes = {};
var parsers = [];
var colorProfiles = {};
var identity = (v) => v;
var useMode = (definition28) => {
converters[definition28.mode] = {
...converters[definition28.mode],
...definition28.toMode
};
Object.keys(definition28.fromMode || {}).forEach((k4) => {
if (!converters[k4]) {
converters[k4] = {};
}
converters[k4][definition28.mode] = definition28.fromMode[k4];
});
if (!definition28.ranges) {
definition28.ranges = {};
}
if (!definition28.difference) {
definition28.difference = {};
}
definition28.channels.forEach((channel) => {
if (definition28.ranges[channel] === void 0) {
definition28.ranges[channel] = [0, 1];
}
if (!definition28.interpolate[channel]) {
throw new Error(`Missing interpolator for: ${channel}`);
}
if (typeof definition28.interpolate[channel] === "function") {
definition28.interpolate[channel] = {
use: definition28.interpolate[channel]
};
}
if (!definition28.interpolate[channel].fixup) {
definition28.interpolate[channel].fixup = identity;
}
});
modes[definition28.mode] = definition28;
(definition28.parse || []).forEach((parser) => {
useParser(parser, definition28.mode);
});
return converter_default(definition28.mode);
};
var getMode = (mode) => modes[mode];
var useParser = (parser, mode) => {
if (typeof parser === "string") {
if (!mode) {
throw new Error(`'mode' required when 'parser' is a string`);
}
colorProfiles[parser] = mode;
} else if (typeof parser === "function") {
if (parsers.indexOf(parser) < 0) {
parsers.push(parser);
}
}
};
var removeParser = (parser) => {
if (typeof parser === "string") {
delete colorProfiles[parser];
} else if (typeof parser === "function") {
const idx = parsers.indexOf(parser);
if (idx > 0) {
parsers.splice(idx, 1);
}
}
};
// src/parse.js
var IdentStartCodePoint = /[^\x00-\x7F]|[a-zA-Z_]/;
var IdentCodePoint = /[^\x00-\x7F]|[-\w]/;
var Tok = {
Function: "function",
Ident: "ident",
Number: "number",
Percentage: "percentage",
ParenClose: ")",
None: "none",
Hue: "hue",
Alpha: "alpha"
};
var _i = 0;
function is_num(chars) {
let ch = chars[_i];
let ch1 = chars[_i + 1];
if (ch === "-" || ch === "+") {
return /\d/.test(ch1) || ch1 === "." && /\d/.test(chars[_i + 2]);
}
if (ch === ".") {
return /\d/.test(ch1);
}
return /\d/.test(ch);
}
function is_ident(chars) {
if (_i >= chars.length) {
return false;
}
let ch = chars[_i];
if (IdentStartCodePoint.test(ch)) {
return true;
}
if (ch === "-") {
if (chars.length - _i < 2) {
return false;
}
let ch1 = chars[_i + 1];
if (ch1 === "-" || IdentStartCodePoint.test(ch1)) {
return true;
}
return false;
}
return false;
}
var huenits = {
deg: 1,
rad: 180 / Math.PI,
grad: 9 / 10,
turn: 360
};
function num2(chars) {
let value = "";
if (chars[_i] === "-" || chars[_i] === "+") {
value += chars[_i++];
}
value += digits(chars);
if (chars[_i] === "." && /\d/.test(chars[_i + 1])) {
value += chars[_i++] + digits(chars);
}
if (chars[_i] === "e" || chars[_i] === "E") {
if ((chars[_i + 1] === "-" || chars[_i + 1] === "+") && /\d/.test(chars[_i + 2])) {
value += chars[_i++] + chars[_i++] + digits(chars);
} else if (/\d/.test(chars[_i + 1])) {
value += chars[_i++] + digits(chars);
}
}
if (is_ident(chars)) {
let id = ident(chars);
if (id === "deg" || id === "rad" || id === "turn" || id === "grad") {
return { type: Tok.Hue, value: value * huenits[id] };
}
return void 0;
}
if (chars[_i] === "%") {
_i++;
return { type: Tok.Percentage, value: +value };
}
return { type: Tok.Number, value: +value };
}
function digits(chars) {
let v = "";
while (/\d/.test(chars[_i])) {
v += chars[_i++];
}
return v;
}
function ident(chars) {
let v = "";
while (_i < chars.length && IdentCodePoint.test(chars[_i])) {
v += chars[_i++];
}
return v;
}
function identlike(chars) {
let v = ident(chars);
if (chars[_i] === "(") {
_i++;
return { type: Tok.Function, value: v };
}
if (v === "none") {
return { type: Tok.None, value: void 0 };
}
return { type: Tok.Ident, value: v };
}
function tokenize(str = "") {
let chars = str.trim();
let tokens = [];
let ch;
_i = 0;
while (_i < chars.length) {
ch = chars[_i++];
if (ch === "\n" || ch === " " || ch === " ") {
while (_i < chars.length && (chars[_i] === "\n" || chars[_i] === " " || chars[_i] === " ")) {
_i++;
}
continue;
}
if (ch === ",") {
return void 0;
}
if (ch === ")") {
tokens.push({ type: Tok.ParenClose });
continue;
}
if (ch === "+") {
_i--;
if (is_num(chars)) {
tokens.push(num2(chars));
continue;
}
return void 0;
}
if (ch === "-") {
_i--;
if (is_num(chars)) {
tokens.push(num2(chars));
continue;
}
if (is_ident(chars)) {
tokens.push({ type: Tok.Ident, value: ident(chars) });
continue;
}
return void 0;
}
if (ch === ".") {
_i--;
if (is_num(chars)) {
tokens.push(num2(chars));
continue;
}
return void 0;
}
if (ch === "/") {
while (_i < chars.length && (chars[_i] === "\n" || chars[_i] === " " || chars[_i] === " ")) {
_i++;
}
let alpha;
if (is_num(chars)) {
alpha = num2(chars);
if (alpha.type !== Tok.Hue) {
tokens.push({ type: Tok.Alpha, value: alpha });
continue;
}
}
if (is_ident(chars)) {
if (ident(chars) === "none") {
tokens.push({
type: Tok.Alpha,
value: { type: Tok.None, value: void 0 }
});
continue;
}
}
return void 0;
}
if (/\d/.test(ch)) {
_i--;
tokens.push(num2(chars));
continue;
}
if (IdentStartCodePoint.test(ch)) {
_i--;
tokens.push(identlike(chars));
continue;
}
return void 0;
}
return tokens;
}
function parseColorSyntax(tokens) {
tokens._i = 0;
let token = tokens[tokens._i++];
if (!token || token.type !== Tok.Function || token.value !== "color") {
return void 0;
}
token = tokens[tokens._i++];
if (token.type !== Tok.Ident) {
return void 0;
}
const mode = colorProfiles[token.value];
if (!mode) {
return void 0;
}
const res = { mode };
const coords = consumeCoords(tokens, false);
if (!coords) {
return void 0;
}
const channels = getMode(mode).channels;
for (let ii = 0, c4; ii < channels.length; ii++) {
c4 = coords[ii];
if (c4.type !== Tok.None) {
res[channels[ii]] = c4.type === Tok.Number ? c4.value : c4.value / 100;
}
}
return res;
}
function consumeCoords(tokens, includeHue) {
const coords = [];
let token;
while (tokens._i < tokens.length) {
token = tokens[tokens._i++];
if (token.type === Tok.None || token.type === Tok.Number || token.type === Tok.Alpha || token.type === Tok.Percentage || includeHue && token.type === Tok.Hue) {
coords.push(token);
continue;
}
if (token.type === Tok.ParenClose) {
if (tokens._i < tokens.length) {
return void 0;
}
continue;
}
return void 0;
}
if (coords.length < 3 || coords.length > 4) {
return void 0;
}
if (coords.length === 4) {
if (coords[3].type !== Tok.Alpha) {
return void 0;
}
coords[3] = coords[3].value;
}
if (coords.length === 3) {
coords.push({ type: Tok.None, value: void 0 });
}
return coords.every((c4) => c4.type !== Tok.Alpha) ? coords : void 0;
}
function parseModernSyntax(tokens, includeHue) {
tokens._i = 0;
let token = tokens[tokens._i++];
if (!token || token.type !== Tok.Function) {
return void 0;
}
let coords = consumeCoords(tokens, includeHue);
if (!coords) {
return void 0;
}
coords.unshift(token.value);
return coords;
}
var parse = (color) => {
if (typeof color !== "string") {
return void 0;
}
const tokens = tokenize(color);
const parsed = tokens ? parseModernSyntax(tokens, true) : void 0;
let result = void 0;
let i = 0;
let len = parsers.length;
while (i < len) {
if ((result = parsers[i++](color, parsed)) !== void 0) {
return result;
}
}
return tokens ? parseColorSyntax(tokens) : void 0;
};
var parse_default = parse;
// src/rgb/parseRgb.js
function parseRgb(color, parsed) {
if (!parsed || parsed[0] !== "rgb" && parsed[0] !== "rgba") {
return void 0;
}
const res = { mode: "rgb" };
const [, r2, g, b, alpha] = parsed;
if (r2.type === Tok.Hue || g.type === Tok.Hue || b.type === Tok.Hue) {
return void 0;
}
if (r2.type !== Tok.None) {
res.r = r2.type === Tok.Number ? r2.value / 255 : r2.value / 100;
}
if (g.type !== Tok.None) {
res.g = g.type === Tok.Number ? g.value / 255 : g.value / 100;
}
if (b.type !== Tok.None) {
res.b = b.type === Tok.Number ? b.value / 255 : b.value / 100;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseRgb_default = parseRgb;
// src/rgb/parseTransparent.js
var parseTransparent = (c4) => c4 === "transparent" ? { mode: "rgb", r: 0, g: 0, b: 0, alpha: 0 } : void 0;
var parseTransparent_default = parseTransparent;
// src/interpolate/lerp.js
var lerp = (a, b, t) => a + t * (b - a);
var unlerp = (a, b, v) => (v - a) / (b - a);
var blerp = (a00, a01, a10, a11, tx, ty) => {
return lerp(lerp(a00, a01, tx), lerp(a10, a11, tx), ty);
};
var trilerp = (a000, a010, a100, a110, a001, a011, a101, a111, tx, ty, tz) => {
return lerp(
blerp(a000, a010, a100, a110, tx, ty),
blerp(a001, a011, a101, a111, tx, ty),
tz
);
};
// src/interpolate/piecewise.js
var get_classes = (arr) => {
let classes = [];
for (let i = 0; i < arr.length - 1; i++) {
let a = arr[i];
let b = arr[i + 1];
if (a === void 0 && b === void 0) {
classes.push(void 0);
} else if (a !== void 0 && b !== void 0) {
classes.push([a, b]);
} else {
classes.push(a !== void 0 ? [a, a] : [b, b]);
}
}
return classes;
};
var interpolatorPiecewise = (interpolator2) => (arr) => {
let classes = get_classes(arr);
return (t) => {
let cls = t * classes.length;
let idx = t >= 1 ? classes.length - 1 : Math.max(Math.floor(cls), 0);
let pair = classes[idx];
return pair === void 0 ? void 0 : interpolator2(pair[0], pair[1], cls - idx);
};
};
// src/interpolate/linear.js
var interpolatorLinear = interpolatorPiecewise(lerp);
// src/fixup/alpha.js
var fixupAlpha = (arr) => {
let some_defined = false;
let res = arr.map((v) => {
if (v !== void 0) {
some_defined = true;
return v;
}
return 1;
});
return some_defined ? res : arr;
};
// src/rgb/definition.js
var definition = {
mode: "rgb",
channels: ["r", "g", "b", "alpha"],
parse: [
parseRgb_default,
parseHex_default,
parseRgbLegacy_default,
parseNamed_default,
parseTransparent_default,
"srgb"
],
serialize: "srgb",
interpolate: {
r: interpolatorLinear,
g: interpolatorLinear,
b: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
gamut: true
};
var definition_default = definition;
// src/a98/convertA98ToXyz65.js
var linearize = (v) => Math.pow(Math.abs(v), 563 / 256) * Math.sign(v);
var convertA98ToXyz65 = (a982) => {
let r2 = linearize(a982.r);
let g = linearize(a982.g);
let b = linearize(a982.b);
let res = {
mode: "xyz65",
x: 0.5766690429101305 * r2 + 0.1855582379065463 * g + 0.1882286462349947 * b,
y: 0.297344975250536 * r2 + 0.6273635662554661 * g + 0.0752914584939979 * b,
z: 0.0270313613864123 * r2 + 0.0706888525358272 * g + 0.9913375368376386 * b
};
if (a982.alpha !== void 0) {
res.alpha = a982.alpha;
}
return res;
};
var convertA98ToXyz65_default = convertA98ToXyz65;
// src/a98/convertXyz65ToA98.js
var gamma = (v) => Math.pow(Math.abs(v), 256 / 563) * Math.sign(v);
var convertXyz65ToA98 = ({ x, y, z, alpha }) => {
let res = {
mode: "a98",
r: gamma(
x * 2.0415879038107465 - y * 0.5650069742788597 - 0.3447313507783297 * z
),
g: gamma(
x * -0.9692436362808798 + y * 1.8759675015077206 + 0.0415550574071756 * z
),
b: gamma(
x * 0.0134442806320312 - y * 0.1183623922310184 + 1.0151749943912058 * z
)
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToA98_default = convertXyz65ToA98;
// src/lrgb/convertRgbToLrgb.js
var fn = (c4) => {
const abs3 = Math.abs(c4);
if (abs3 <= 0.04045) {
return c4 / 12.92;
}
return (Math.sign(c4) || 1) * Math.pow((abs3 + 0.055) / 1.055, 2.4);
};
var convertRgbToLrgb = ({ r: r2, g, b, alpha }) => {
let res = {
mode: "lrgb",
r: fn(r2),
g: fn(g),
b: fn(b)
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertRgbToLrgb_default = convertRgbToLrgb;
// src/xyz65/convertRgbToXyz65.js
var convertRgbToXyz65 = (rgb4) => {
let { r: r2, g, b, alpha } = convertRgbToLrgb_default(rgb4);
let res = {
mode: "xyz65",
x: 0.4123907992659593 * r2 + 0.357584339383878 * g + 0.1804807884018343 * b,
y: 0.2126390058715102 * r2 + 0.715168678767756 * g + 0.0721923153607337 * b,
z: 0.0193308187155918 * r2 + 0.119194779794626 * g + 0.9505321522496607 * b
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertRgbToXyz65_default = convertRgbToXyz65;
// src/lrgb/convertLrgbToRgb.js
var fn2 = (c4) => {
const abs3 = Math.abs(c4);
if (abs3 > 31308e-7) {
return (Math.sign(c4) || 1) * (1.055 * Math.pow(abs3, 1 / 2.4) - 0.055);
}
return c4 * 12.92;
};
var convertLrgbToRgb = ({ r: r2, g, b, alpha }, mode = "rgb") => {
let res = {
mode,
r: fn2(r2),
g: fn2(g),
b: fn2(b)
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertLrgbToRgb_default = convertLrgbToRgb;
// src/xyz65/convertXyz65ToRgb.js
var convertXyz65ToRgb = ({ x, y, z, alpha }) => {
let res = convertLrgbToRgb_default({
r: x * 3.2409699419045226 - y * 1.537383177570094 - 0.4986107602930034 * z,
g: x * -0.9692436362808796 + y * 1.8759675015077204 + 0.0415550574071756 * z,
b: x * 0.0556300796969936 - y * 0.2039769588889765 + 1.0569715142428784 * z
});
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToRgb_default = convertXyz65ToRgb;
// src/a98/definition.js
var definition2 = {
...definition_default,
mode: "a98",
parse: ["a98-rgb"],
serialize: "a98-rgb",
fromMode: {
rgb: (color) => convertXyz65ToA98_default(convertRgbToXyz65_default(color)),
xyz65: convertXyz65ToA98_default
},
toMode: {
rgb: (color) => convertXyz65ToRgb_default(convertA98ToXyz65_default(color)),
xyz65: convertA98ToXyz65_default
}
};
var definition_default2 = definition2;
// src/util/normalizeHue.js
var normalizeHue = (hue3) => (hue3 = hue3 % 360) < 0 ? hue3 + 360 : hue3;
var normalizeHue_default = normalizeHue;
// src/fixup/hue.js
var hue2 = (hues, fn5) => {
return hues.map((hue3, idx, arr) => {
if (hue3 === void 0) {
return hue3;
}
let normalized = normalizeHue_default(hue3);
if (idx === 0 || hues[idx - 1] === void 0) {
return normalized;
}
return fn5(normalized - normalizeHue_default(arr[idx - 1]));
}).reduce((acc, curr) => {
if (!acc.length || curr === void 0 || acc[acc.length - 1] === void 0) {
acc.push(curr);
return acc;
}
acc.push(curr + acc[acc.length - 1]);
return acc;
}, []);
};
var fixupHueShorter = (arr) => hue2(arr, (d) => Math.abs(d) <= 180 ? d : d - 360 * Math.sign(d));
var fixupHueLonger = (arr) => hue2(arr, (d) => Math.abs(d) >= 180 || d === 0 ? d : d - 360 * Math.sign(d));
var fixupHueIncreasing = (arr) => hue2(arr, (d) => d >= 0 ? d : d + 360);
var fixupHueDecreasing = (arr) => hue2(arr, (d) => d <= 0 ? d : d - 360);
// src/cubehelix/constants.js
var M = [-0.14861, 1.78277, -0.29227, -0.90649, 1.97294, 0];
var degToRad = Math.PI / 180;
var radToDeg = 180 / Math.PI;
// src/cubehelix/convertRgbToCubehelix.js
var DE = M[3] * M[4];
var BE = M[1] * M[4];
var BCAD = M[1] * M[2] - M[0] * M[3];
var convertRgbToCubehelix = ({ r: r2, g, b, alpha }) => {
let l = (BCAD * b + r2 * DE - g * BE) / (BCAD + DE - BE);
let x = b - l;
let y = (M[4] * (g - l) - M[2] * x) / M[3];
let res = {
mode: "cubehelix",
l,
s: l === 0 || l === 1 ? void 0 : Math.sqrt(x * x + y * y) / (M[4] * l * (1 - l))
};
if (res.s)
res.h = Math.atan2(y, x) * radToDeg - 120;
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertRgbToCubehelix_default = convertRgbToCubehelix;
// src/cubehelix/convertCubehelixToRgb.js
var convertCubehelixToRgb = ({ h, s, l, alpha }) => {
let res = { mode: "rgb" };
h = (h === void 0 ? 0 : h + 120) * degToRad;
let amp = s === void 0 ? 0 : s * l * (1 - l);
let cosh = Math.cos(h);
let sinh = Math.sin(h);
res.r = l + amp * (M[0] * cosh + M[1] * sinh);
res.g = l + amp * (M[2] * cosh + M[3] * sinh);
res.b = l + amp * (M[4] * cosh + M[5] * sinh);
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertCubehelixToRgb_default = convertCubehelixToRgb;
// src/difference.js
var differenceHueSaturation = (std, smp) => {
if (std.h === void 0 || smp.h === void 0 || !std.s || !smp.s) {
return 0;
}
let std_h = normalizeHue_default(std.h);
let smp_h = normalizeHue_default(smp.h);
let dH = Math.sin((smp_h - std_h + 360) / 2 * Math.PI / 180);
return 2 * Math.sqrt(std.s * smp.s) * dH;
};
var differenceHueNaive = (std, smp) => {
if (std.h === void 0 || smp.h === void 0) {
return 0;
}
let std_h = normalizeHue_default(std.h);
let smp_h = normalizeHue_default(smp.h);
if (Math.abs(smp_h - std_h) > 180) {
return std_h - (smp_h - 360 * Math.sign(smp_h - std_h));
}
return smp_h - std_h;
};
var differenceHueChroma = (std, smp) => {
if (std.h === void 0 || smp.h === void 0 || !std.c || !smp.c) {
return 0;
}
let std_h = normalizeHue_default(std.h);
let smp_h = normalizeHue_default(smp.h);
let dH = Math.sin((smp_h - std_h + 360) / 2 * Math.PI / 180);
return 2 * Math.sqrt(std.c * smp.c) * dH;
};
var differenceEuclidean = (mode = "rgb", weights = [1, 1, 1, 0]) => {
let def = getMode(mode);
let channels = def.channels;
let diffs = def.difference;
let conv = converter_default(mode);
return (std, smp) => {
let ConvStd = conv(std);
let ConvSmp = conv(smp);
return Math.sqrt(
channels.reduce((sum, k4, idx) => {
let delta = diffs[k4] ? diffs[k4](ConvStd, ConvSmp) : ConvStd[k4] - ConvSmp[k4];
return sum + (weights[idx] || 0) * Math.pow(isNaN(delta) ? 0 : delta, 2);
}, 0)
);
};
};
var differenceCie76 = () => differenceEuclidean("lab65");
var differenceCie94 = (kL = 1, K1 = 0.045, K2 = 0.015) => {
let lab2 = converter_default("lab65");
return (std, smp) => {
let LabStd = lab2(std);
let LabSmp = lab2(smp);
let lStd = LabStd.l;
let aStd = LabStd.a;
let bStd = LabStd.b;
let cStd = Math.sqrt(aStd * aStd + bStd * bStd);
let lSmp = LabSmp.l;
let aSmp = LabSmp.a;
let bSmp = LabSmp.b;
let cSmp = Math.sqrt(aSmp * aSmp + bSmp * bSmp);
let dL2 = Math.pow(lStd - lSmp, 2);
let dC2 = Math.pow(cStd - cSmp, 2);
let dH2 = Math.pow(aStd - aSmp, 2) + Math.pow(bStd - bSmp, 2) - dC2;
return Math.sqrt(
dL2 / Math.pow(kL, 2) + dC2 / Math.pow(1 + K1 * cStd, 2) + dH2 / Math.pow(1 + K2 * cStd, 2)
);
};
};
var differenceCiede2000 = (Kl = 1, Kc = 1, Kh = 1) => {
let lab2 = converter_default("lab65");
return (std, smp) => {
let LabStd = lab2(std);
let LabSmp = lab2(smp);
let lStd = LabStd.l;
let aStd = LabStd.a;
let bStd = LabStd.b;
let cStd = Math.sqrt(aStd * aStd + bStd * bStd);
let lSmp = LabSmp.l;
let aSmp = LabSmp.a;
let bSmp = LabSmp.b;
let cSmp = Math.sqrt(aSmp * aSmp + bSmp * bSmp);
let cAvg = (cStd + cSmp) / 2;
let G = 0.5 * (1 - Math.sqrt(
Math.pow(cAvg, 7) / (Math.pow(cAvg, 7) + Math.pow(25, 7))
));
let apStd = aStd * (1 + G);
let apSmp = aSmp * (1 + G);
let cpStd = Math.sqrt(apStd * apStd + bStd * bStd);
let cpSmp = Math.sqrt(apSmp * apSmp + bSmp * bSmp);
let hpStd = Math.abs(apStd) + Math.abs(bStd) === 0 ? 0 : Math.atan2(bStd, apStd);
hpStd += (hpStd < 0) * 2 * Math.PI;
let hpSmp = Math.abs(apSmp) + Math.abs(bSmp) === 0 ? 0 : Math.atan2(bSmp, apSmp);
hpSmp += (hpSmp < 0) * 2 * Math.PI;
let dL = lSmp - lStd;
let dC = cpSmp - cpStd;
let dhp = cpStd * cpSmp === 0 ? 0 : hpSmp - hpStd;
dhp -= (dhp > Math.PI) * 2 * Math.PI;
dhp += (dhp < -Math.PI) * 2 * Math.PI;
let dH = 2 * Math.sqrt(cpStd * cpSmp) * Math.sin(dhp / 2);
let Lp = (lStd + lSmp) / 2;
let Cp = (cpStd + cpSmp) / 2;
let hp;
if (cpStd * cpSmp === 0) {
hp = hpStd + hpSmp;
} else {
hp = (hpStd + hpSmp) / 2;
hp -= (Math.abs(hpStd - hpSmp) > Math.PI) * Math.PI;
hp += (hp < 0) * 2 * Math.PI;
}
let Lpm50 = Math.pow(Lp - 50, 2);
let T = 1 - 0.17 * Math.cos(hp - Math.PI / 6) + 0.24 * Math.cos(2 * hp) + 0.32 * Math.cos(3 * hp + Math.PI / 30) - 0.2 * Math.cos(4 * hp - 63 * Math.PI / 180);
let Sl = 1 + 0.015 * Lpm50 / Math.sqrt(20 + Lpm50);
let Sc = 1 + 0.045 * Cp;
let Sh = 1 + 0.015 * Cp * T;
let deltaTheta = 30 * Math.PI / 180 * Math.exp(-1 * Math.pow((180 / Math.PI * hp - 275) / 25, 2));
let Rc = 2 * Math.sqrt(Math.pow(Cp, 7) / (Math.pow(Cp, 7) + Math.pow(25, 7)));
let Rt = -1 * Math.sin(2 * deltaTheta) * Rc;
return Math.sqrt(
Math.pow(dL / (Kl * Sl), 2) + Math.pow(dC / (Kc * Sc), 2) + Math.pow(dH / (Kh * Sh), 2) + Rt * dC / (Kc * Sc) * dH / (Kh * Sh)
);
};
};
var differenceCmc = (l = 1, c4 = 1) => {
let lab2 = converter_default("lab65");
return (std, smp) => {
let LabStd = lab2(std);
let lStd = LabStd.l;
let aStd = LabStd.a;
let bStd = LabStd.b;
let cStd = Math.sqrt(aStd * aStd + bStd * bStd);
let hStd = Math.atan2(bStd, aStd);
hStd = hStd + 2 * Math.PI * (hStd < 0);
let LabSmp = lab2(smp);
let lSmp = LabSmp.l;
let aSmp = LabSmp.a;
let bSmp = LabSmp.b;
let cSmp = Math.sqrt(aSmp * aSmp + bSmp * bSmp);
let dL2 = Math.pow(lStd - lSmp, 2);
let dC2 = Math.pow(cStd - cSmp, 2);
let dH2 = Math.pow(aStd - aSmp, 2) + Math.pow(bStd - bSmp, 2) - dC2;
let F = Math.sqrt(Math.pow(cStd, 4) / (Math.pow(cStd, 4) + 1900));
let T = hStd >= 164 / 180 * Math.PI && hStd <= 345 / 180 * Math.PI ? 0.56 + Math.abs(0.2 * Math.cos(hStd + 168 / 180 * Math.PI)) : 0.36 + Math.abs(0.4 * Math.cos(hStd + 35 / 180 * Math.PI));
let Sl = lStd < 16 ? 0.511 : 0.040975 * lStd / (1 + 0.01765 * lStd);
let Sc = 0.0638 * cStd / (1 + 0.0131 * cStd) + 0.638;
let Sh = Sc * (F * T + 1 - F);
return Math.sqrt(
dL2 / Math.pow(l * Sl, 2) + dC2 / Math.pow(c4 * Sc, 2) + dH2 / Math.pow(Sh, 2)
);
};
};
var differenceHyab = () => {
let lab2 = converter_default("lab65");
return (std, smp) => {
let LabStd = lab2(std);
let LabSmp = lab2(smp);
let dL = LabStd.l - LabSmp.l;
let dA = LabStd.a - LabSmp.a;
let dB = LabStd.b - LabSmp.b;
return Math.abs(dL) + Math.sqrt(dA * dA + dB * dB);
};
};
var differenceKotsarenkoRamos = () => differenceEuclidean("yiq", [0.5053, 0.299, 0.1957]);
// src/average.js
var averageAngle = (val) => {
let sum = val.reduce(
(sum2, val2) => {
if (val2 !== void 0) {
let rad = val2 * Math.PI / 180;
sum2.sin += Math.sin(rad);
sum2.cos += Math.cos(rad);
}
return sum2;
},
{ sin: 0, cos: 0 }
);
return Math.atan2(sum.sin, sum.cos) * 180 / Math.PI;
};
var averageNumber = (val) => {
let a = val.filter((v) => v !== void 0);
return a.length ? a.reduce((sum, v) => sum + v, 0) / a.length : void 0;
};
var isfn = (o) => typeof o === "function";
function average(colors, mode = "rgb", overrides) {
let def = getMode(mode);
let cc = colors.map(converter_default(mode));
return def.channels.reduce(
(res, ch) => {
let arr = cc.map((c4) => c4[ch]).filter((val) => val !== void 0);
if (arr.length) {
let fn5;
if (isfn(overrides)) {
fn5 = overrides;
} else if (overrides && isfn(overrides[ch])) {
fn5 = overrides[ch];
} else if (def.average && isfn(def.average[ch])) {
fn5 = def.average[ch];
} else {
fn5 = averageNumber;
}
res[ch] = fn5(arr, ch);
}
return res;
},
{ mode }
);
}
// src/cubehelix/definition.js
var definition3 = {
mode: "cubehelix",
channels: ["h", "s", "l", "alpha"],
parse: ["--cubehelix"],
serialize: "--cubehelix",
ranges: {
h: [0, 360],
s: [0, 4.614],
l: [0, 1]
},
fromMode: {
rgb: convertRgbToCubehelix_default
},
toMode: {
rgb: convertCubehelixToRgb_default
},
interpolate: {
h: {
use: interpolatorLinear,
fixup: fixupHueShorter
},
s: interpolatorLinear,
l: interpolatorLinear,
alpha: {
use: interpolatorLinear,
fixup: fixupAlpha
}
},
difference: {
h: differenceHueSaturation
},
average: {
h: averageAngle
}
};
var definition_default3 = definition3;
// src/lch/convertLabToLch.js
var convertLabToLch = ({ l, a, b, alpha }, mode = "lch") => {
let c4 = Math.sqrt(a * a + b * b);
let res = { mode, l, c: c4 };
if (c4)
res.h = normalizeHue_default(Math.atan2(b, a) * 180 / Math.PI);
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertLabToLch_default = convertLabToLch;
// src/lch/convertLchToLab.js
var convertLchToLab = ({ l, c: c4, h, alpha }, mode = "lab") => {
let res = {
mode,
l,
a: c4 ? c4 * Math.cos(h / 180 * Math.PI) : 0,
b: c4 ? c4 * Math.sin(h / 180 * Math.PI) : 0
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertLchToLab_default = convertLchToLab;
// src/xyz65/constants.js
var k = Math.pow(29, 3) / Math.pow(3, 3);
var e = Math.pow(6, 3) / Math.pow(29, 3);
// src/constants.js
var D50 = {
X: 0.3457 / 0.3585,
Y: 1,
Z: (1 - 0.3457 - 0.3585) / 0.3585
};
var D65 = {
X: 0.3127 / 0.329,
Y: 1,
Z: (1 - 0.3127 - 0.329) / 0.329
};
var k2 = Math.pow(29, 3) / Math.pow(3, 3);
var e2 = Math.pow(6, 3) / Math.pow(29, 3);
// src/lab65/convertLab65ToXyz65.js
var fn3 = (v) => Math.pow(v, 3) > e ? Math.pow(v, 3) : (116 * v - 16) / k;
var convertLab65ToXyz65 = ({ l, a, b, alpha }) => {
let fy = (l + 16) / 116;
let fx = a / 500 + fy;
let fz = fy - b / 200;
let res = {
mode: "xyz65",
x: fn3(fx) * D65.X,
y: fn3(fy) * D65.Y,
z: fn3(fz) * D65.Z
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertLab65ToXyz65_default = convertLab65ToXyz65;
// src/lab65/convertLab65ToRgb.js
var convertLab65ToRgb = (lab2) => convertXyz65ToRgb_default(convertLab65ToXyz65_default(lab2));
var convertLab65ToRgb_default = convertLab65ToRgb;
// src/lab65/convertXyz65ToLab65.js
var f = (value) => value > e ? Math.cbrt(value) : (k * value + 16) / 116;
var convertXyz65ToLab65 = ({ x, y, z, alpha }) => {
let f0 = f(x / D65.X);
let f1 = f(y / D65.Y);
let f22 = f(z / D65.Z);
let res = {
mode: "lab65",
l: 116 * f1 - 16,
a: 500 * (f0 - f1),
b: 200 * (f1 - f22)
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToLab65_default = convertXyz65ToLab65;
// src/lab65/convertRgbToLab65.js
var convertRgbToLab65 = (rgb4) => {
let res = convertXyz65ToLab65_default(convertRgbToXyz65_default(rgb4));
if (rgb4.r === rgb4.b && rgb4.b === rgb4.g) {
res.a = res.b = 0;
}
return res;
};
var convertRgbToLab65_default = convertRgbToLab65;
// src/dlch/constants.js
var kE = 1;
var kCH = 1;
var \u03B8 = 26 / 180 * Math.PI;
var cos\u03B8 = Math.cos(\u03B8);
var sin\u03B8 = Math.sin(\u03B8);
var factor = 100 / Math.log(139 / 100);
// src/dlch/convertDlchToLab65.js
var convertDlchToLab65 = ({ l, c: c4, h, alpha }) => {
let res = {
mode: "lab65",
l: (Math.exp(l * kE / factor) - 1) / 39e-4
};
if (h === void 0) {
res.a = res.b = 0;
} else {
let G = (Math.exp(0.0435 * c4 * kCH * kE) - 1) / 0.075;
let e4 = G * Math.cos(h / 180 * Math.PI - \u03B8);
let f3 = G * Math.sin(h / 180 * Math.PI - \u03B8);
res.a = e4 * cos\u03B8 - f3 / 0.83 * sin\u03B8;
res.b = e4 * sin\u03B8 + f3 / 0.83 * cos\u03B8;
}
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertDlchToLab65_default = convertDlchToLab65;
// src/dlch/convertLab65ToDlch.js
var convertLab65ToDlch = ({ l, a, b, alpha }) => {
let e4 = a * cos\u03B8 + b * sin\u03B8;
let f3 = 0.83 * (b * cos\u03B8 - a * sin\u03B8);
let G = Math.sqrt(e4 * e4 + f3 * f3);
let res = {
mode: "dlch",
l: factor / kE * Math.log(1 + 39e-4 * l),
c: Math.log(1 + 0.075 * G) / (0.0435 * kCH * kE)
};
if (res.c) {
res.h = normalizeHue_default((Math.atan2(f3, e4) + \u03B8) / Math.PI * 180);
}
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertLab65ToDlch_default = convertLab65ToDlch;
// src/dlab/definition.js
var convertDlabToLab65 = (c4) => convertDlchToLab65_default(convertLabToLch_default(c4, "dlch"));
var convertLab65ToDlab = (c4) => convertLchToLab_default(convertLab65ToDlch_default(c4), "dlab");
var definition4 = {
mode: "dlab",
parse: ["--din99o-lab"],
serialize: "--din99o-lab",
toMode: {
lab65: convertDlabToLab65,
rgb: (c4) => convertLab65ToRgb_default(convertDlabToLab65(c4))
},
fromMode: {
lab65: convertLab65ToDlab,
rgb: (c4) => convertLab65ToDlab(convertRgbToLab65_default(c4))
},
channels: ["l", "a", "b", "alpha"],
ranges: {
l: [0, 100],
a: [-40.09, 45.501],
b: [-40.469, 44.344]
},
interpolate: {
l: interpolatorLinear,
a: interpolatorLinear,
b: interpolatorLinear,
alpha: {
use: interpolatorLinear,
fixup: fixupAlpha
}
}
};
var definition_default4 = definition4;
// src/dlch/definition.js
var definition5 = {
mode: "dlch",
parse: ["--din99o-lch"],
serialize: "--din99o-lch",
toMode: {
lab65: convertDlchToLab65_default,
dlab: (c4) => convertLchToLab_default(c4, "dlab"),
rgb: (c4) => convertLab65ToRgb_default(convertDlchToLab65_default(c4))
},
fromMode: {
lab65: convertLab65ToDlch_default,
dlab: (c4) => convertLabToLch_default(c4, "dlch"),
rgb: (c4) => convertLab65ToDlch_default(convertRgbToLab65_default(c4))
},
channels: ["l", "c", "h", "alpha"],
ranges: {
l: [0, 100],
c: [0, 51.484],
h: [0, 360]
},
interpolate: {
l: interpolatorLinear,
c: interpolatorLinear,
h: {
use: interpolatorLinear,
fixup: fixupHueShorter
},
alpha: {
use: interpolatorLinear,
fixup: fixupAlpha
}
},
difference: {
h: differenceHueChroma
},
average: {
h: averageAngle
}
};
var definition_default5 = definition5;
// src/hsi/convertHsiToRgb.js
function convertHsiToRgb({ h, s, i, alpha }) {
h = normalizeHue_default(h);
let f3 = Math.abs(h / 60 % 2 - 1);
let res;
switch (Math.floor(h / 60)) {
case 0:
res = {
r: i * (1 + s * (3 / (2 - f3) - 1)),
g: i * (1 + s * (3 * (1 - f3) / (2 - f3) - 1)),
b: i * (1 - s)
};
break;
case 1:
res = {
r: i * (1 + s * (3 * (1 - f3) / (2 - f3) - 1)),
g: i * (1 + s * (3 / (2 - f3) - 1)),
b: i * (1 - s)
};
break;
case 2:
res = {
r: i * (1 - s),
g: i * (1 + s * (3 / (2 - f3) - 1)),
b: i * (1 + s * (3 * (1 - f3) / (2 - f3) - 1))
};
break;
case 3:
res = {
r: i * (1 - s),
g: i * (1 + s * (3 * (1 - f3) / (2 - f3) - 1)),
b: i * (1 + s * (3 / (2 - f3) - 1))
};
break;
case 4:
res = {
r: i * (1 + s * (3 * (1 - f3) / (2 - f3) - 1)),
g: i * (1 - s),
b: i * (1 + s * (3 / (2 - f3) - 1))
};
break;
case 5:
res = {
r: i * (1 + s * (3 / (2 - f3) - 1)),
g: i * (1 - s),
b: i * (1 + s * (3 * (1 - f3) / (2 - f3) - 1))
};
break;
default:
res = { r: i * (1 - s), g: i * (1 - s), b: i * (1 - s) };
}
res.mode = "rgb";
if (alpha !== void 0)
res.alpha = alpha;
return res;
}
// src/hsi/convertRgbToHsi.js
function convertRgbToHsi({ r: r2, g, b, alpha }) {
let M2 = Math.max(r2, g, b), m = Math.min(r2, g, b);
let res = {
mode: "hsi",
s: r2 + g + b === 0 ? 0 : 1 - 3 * m / (r2 + g + b),
i: (r2 + g + b) / 3
};
if (M2 - m !== 0)
res.h = (M2 === r2 ? (g - b) / (M2 - m) + (g < b) * 6 : M2 === g ? (b - r2) / (M2 - m) + 2 : (r2 - g) / (M2 - m) + 4) * 60;
if (alpha !== void 0)
res.alpha = alpha;
return res;
}
// src/hsi/definition.js
var definition6 = {
mode: "hsi",
toMode: {
rgb: convertHsiToRgb
},
parse: ["--hsi"],
serialize: "--hsi",
fromMode: {
rgb: convertRgbToHsi
},
channels: ["h", "s", "i", "alpha"],
ranges: {
h: [0, 360]
},
gamut: "rgb",
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
s: interpolatorLinear,
i: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueSaturation
},
average: {
h: averageAngle
}
};
var definition_default6 = definition6;
// src/hsl/convertHslToRgb.js
function convertHslToRgb({ h, s, l, alpha }) {
h = normalizeHue_default(h);
let m1 = l + s * (l < 0.5 ? l : 1 - l);
let m2 = m1 - (m1 - l) * 2 * Math.abs(h / 60 % 2 - 1);
let res;
switch (Math.floor(h / 60)) {
case 0:
res = { r: m1, g: m2, b: 2 * l - m1 };
break;
case 1:
res = { r: m2, g: m1, b: 2 * l - m1 };
break;
case 2:
res = { r: 2 * l - m1, g: m1, b: m2 };
break;
case 3:
res = { r: 2 * l - m1, g: m2, b: m1 };
break;
case 4:
res = { r: m2, g: 2 * l - m1, b: m1 };
break;
case 5:
res = { r: m1, g: 2 * l - m1, b: m2 };
break;
default:
res = { r: 2 * l - m1, g: 2 * l - m1, b: 2 * l - m1 };
}
res.mode = "rgb";
if (alpha !== void 0)
res.alpha = alpha;
return res;
}
// src/hsl/convertRgbToHsl.js
function convertRgbToHsl({ r: r2, g, b, alpha }) {
let M2 = Math.max(r2, g, b), m = Math.min(r2, g, b);
let res = {
mode: "hsl",
s: M2 === m ? 0 : (M2 - m) / (1 - Math.abs(M2 + m - 1)),
l: 0.5 * (M2 + m)
};
if (M2 - m !== 0)
res.h = (M2 === r2 ? (g - b) / (M2 - m) + (g < b) * 6 : M2 === g ? (b - r2) / (M2 - m) + 2 : (r2 - g) / (M2 - m) + 4) * 60;
if (alpha !== void 0)
res.alpha = alpha;
return res;
}
// src/util/hue.js
var hueToDeg = (val, unit) => {
switch (unit) {
case "deg":
return +val;
case "rad":
return val / Math.PI * 180;
case "grad":
return val / 10 * 9;
case "turn":
return val * 360;
}
};
var hue_default = hueToDeg;
// src/hsl/parseHslLegacy.js
var hsl_old = new RegExp(
`^hsla?\\(\\s*${hue}${c}${per}${c}${per}\\s*(?:,\\s*${num_per}\\s*)?\\)$`
);
var parseHslLegacy = (color) => {
let match = color.match(hsl_old);
if (!match)
return;
let res = { mode: "hsl" };
if (match[3] !== void 0) {
res.h = +match[3];
} else if (match[1] !== void 0 && match[2] !== void 0) {
res.h = hue_default(match[1], match[2]);
}
if (match[4] !== void 0) {
res.s = Math.min(Math.max(0, match[4] / 100), 1);
}
if (match[5] !== void 0) {
res.l = Math.min(Math.max(0, match[5] / 100), 1);
}
if (match[6] !== void 0) {
res.alpha = match[6] / 100;
} else if (match[7] !== void 0) {
res.alpha = +match[7];
}
return res;
};
var parseHslLegacy_default = parseHslLegacy;
// src/hsl/parseHsl.js
function parseHsl(color, parsed) {
if (!parsed || parsed[0] !== "hsl" && parsed[0] !== "hsla") {
return void 0;
}
const res = { mode: "hsl" };
const [, h, s, l, alpha] = parsed;
if (h.type !== Tok.None) {
if (h.type === Tok.Percentage) {
return void 0;
}
res.h = h.value;
}
if (s.type !== Tok.None) {
if (s.type === Tok.Hue) {
return void 0;
}
res.s = s.type === Tok.Number ? s.value : s.value / 100;
}
if (l.type !== Tok.None) {
if (l.type === Tok.Hue) {
return void 0;
}
res.l = l.type === Tok.Number ? l.value : l.value / 100;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseHsl_default = parseHsl;
// src/hsl/definition.js
var definition7 = {
mode: "hsl",
toMode: {
rgb: convertHslToRgb
},
fromMode: {
rgb: convertRgbToHsl
},
channels: ["h", "s", "l", "alpha"],
ranges: {
h: [0, 360]
},
gamut: "rgb",
parse: [parseHsl_default, parseHslLegacy_default],
serialize: (c4) => `hsl(${c4.h || 0} ${c4.s !== void 0 ? c4.s * 100 + "%" : "none"} ${c4.l !== void 0 ? c4.l * 100 + "%" : "none"}${c4.alpha < 1 ? ` / ${c4.alpha}` : ""})`,
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
s: interpolatorLinear,
l: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueSaturation
},
average: {
h: averageAngle
}
};
var definition_default7 = definition7;
// src/hsv/convertHsvToRgb.js
function convertHsvToRgb({ h, s, v, alpha }) {
h = normalizeHue_default(h);
let f3 = Math.abs(h / 60 % 2 - 1);
let res;
switch (Math.floor(h / 60)) {
case 0:
res = { r: v, g: v * (1 - s * f3), b: v * (1 - s) };
break;
case 1:
res = { r: v * (1 - s * f3), g: v, b: v * (1 - s) };
break;
case 2:
res = { r: v * (1 - s), g: v, b: v * (1 - s * f3) };
break;
case 3:
res = { r: v * (1 - s), g: v * (1 - s * f3), b: v };
break;
case 4:
res = { r: v * (1 - s * f3), g: v * (1 - s), b: v };
break;
case 5:
res = { r: v, g: v * (1 - s), b: v * (1 - s * f3) };
break;
default:
res = { r: v * (1 - s), g: v * (1 - s), b: v * (1 - s) };
}
res.mode = "rgb";
if (alpha !== void 0)
res.alpha = alpha;
return res;
}
// src/hsv/convertRgbToHsv.js
function convertRgbToHsv({ r: r2, g, b, alpha }) {
let M2 = Math.max(r2, g, b), m = Math.min(r2, g, b);
let res = {
mode: "hsv",
s: M2 === 0 ? 0 : 1 - m / M2,
v: M2
};
if (M2 - m !== 0)
res.h = (M2 === r2 ? (g - b) / (M2 - m) + (g < b) * 6 : M2 === g ? (b - r2) / (M2 - m) + 2 : (r2 - g) / (M2 - m) + 4) * 60;
if (alpha !== void 0)
res.alpha = alpha;
return res;
}
// src/hsv/definition.js
var definition8 = {
mode: "hsv",
toMode: {
rgb: convertHsvToRgb
},
parse: ["--hsv"],
serialize: "--hsv",
fromMode: {
rgb: convertRgbToHsv
},
channels: ["h", "s", "v", "alpha"],
ranges: {
h: [0, 360]
},
gamut: "rgb",
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
s: interpolatorLinear,
v: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueSaturation
},
average: {
h: averageAngle
}
};
var definition_default8 = definition8;
// src/hwb/convertHwbToRgb.js
function convertHwbToRgb({ h, w, b, alpha }) {
if (w + b > 1) {
let s = w + b;
w /= s;
b /= s;
}
return convertHsvToRgb({
h,
s: b === 1 ? 1 : 1 - w / (1 - b),
v: 1 - b,
alpha
});
}
// src/hwb/convertRgbToHwb.js
function convertRgbToHwb(rgba) {
let hsv2 = convertRgbToHsv(rgba);
if (hsv2 === void 0)
return void 0;
let res = {
mode: "hwb",
w: (1 - hsv2.s) * hsv2.v,
b: 1 - hsv2.v
};
if (hsv2.h !== void 0)
res.h = hsv2.h;
if (hsv2.alpha !== void 0)
res.alpha = hsv2.alpha;
return res;
}
// src/hwb/parseHwb.js
function ParseHwb(color, parsed) {
if (!parsed || parsed[0] !== "hwb") {
return void 0;
}
const res = { mode: "hwb" };
const [, h, w, b, alpha] = parsed;
if (h.type !== Tok.None) {
if (h.type === Tok.Percentage) {
return void 0;
}
res.h = h.value;
}
if (w.type !== Tok.None) {
if (w.type === Tok.Hue) {
return void 0;
}
res.w = w.type === Tok.Number ? w.value : w.value / 100;
}
if (b.type !== Tok.None) {
if (b.type === Tok.Hue) {
return void 0;
}
res.b = b.type === Tok.Number ? b.value : b.value / 100;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseHwb_default = ParseHwb;
// src/hwb/definition.js
var definition9 = {
mode: "hwb",
toMode: {
rgb: convertHwbToRgb
},
fromMode: {
rgb: convertRgbToHwb
},
channels: ["h", "w", "b", "alpha"],
ranges: {
h: [0, 360]
},
gamut: "rgb",
parse: [parseHwb_default],
serialize: (c4) => `hwb(${c4.h || 0} ${c4.w * 100}% ${c4.b * 100}%${c4.alpha < 1 ? ` / ${c4.alpha}` : ""})`,
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
w: interpolatorLinear,
b: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueNaive
},
average: {
h: averageAngle
}
};
var definition_default9 = definition9;
// src/jab/convertXyz65ToJab.js
var n = 0.1593017578125;
var p = 134.03437499999998;
var c1 = 0.8359375;
var c2 = 18.8515625;
var c3 = 18.6875;
var d0 = 16295499532821565e-27;
var pq = (v) => {
let vn3 = Math.pow(v / 1e4, n);
return Math.pow((c1 + c2 * vn3) / (1 + c3 * vn3), p) || 0;
};
var abs = (v) => Math.max(v * 203, 0);
var convertXyz65ToJab = ({ x, y, z, alpha }) => {
x = abs(x);
y = abs(y);
z = abs(z);
let xp = 1.15 * x - 0.15 * z;
let yp = 0.66 * y + 0.34 * x;
let l = pq(0.41478972 * xp + 0.579999 * yp + 0.014648 * z);
let m = pq(-0.20151 * xp + 1.120649 * yp + 0.0531008 * z);
let s = pq(-0.0166008 * xp + 0.2648 * yp + 0.6684799 * z);
let i = (l + m) / 2;
let res = {
mode: "jab",
j: 0.44 * i / (1 - 0.56 * i) - d0,
a: 3.524 * l - 4.066708 * m + 0.542708 * s,
b: 0.199076 * l + 1.096799 * m - 1.295875 * s
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToJab_default = convertXyz65ToJab;
// src/jab/convertJabToXyz65.js
var n2 = 0.1593017578125;
var p2 = 134.03437499999998;
var c12 = 0.8359375;
var c22 = 18.8515625;
var c32 = 18.6875;
var d02 = 16295499532821565e-27;
var pq_inv = (v) => {
let vp = Math.pow(v, 1 / p2);
return 1e4 * Math.pow((c12 - vp) / (c32 * vp - c22), 1 / n2) || 0;
};
var rel = (v) => v / 203;
var convertJabToXyz65 = ({ j, a, b, alpha }) => {
let i = (j + d02) / (0.44 + 0.56 * (j + d02));
let l = pq_inv(i + 0.13860504 * a + 0.058047316 * b);
let m = pq_inv(i - 0.13860504 * a - 0.058047316 * b);
let s = pq_inv(i - 0.096019242 * a - 0.8118919 * b);
let res = {
mode: "xyz65",
x: rel(
1.661373024652174 * l - 0.914523081304348 * m + 0.23136208173913045 * s
),
y: rel(
-0.3250758611844533 * l + 1.571847026732543 * m - 0.21825383453227928 * s
),
z: rel(-0.090982811 * l - 0.31272829 * m + 1.5227666 * s)
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertJabToXyz65_default = convertJabToXyz65;
// src/jab/convertRgbToJab.js
var convertRgbToJab = (rgb4) => {
let res = convertXyz65ToJab_default(convertRgbToXyz65_default(rgb4));
if (rgb4.r === rgb4.b && rgb4.b === rgb4.g) {
res.a = res.b = 0;
}
return res;
};
var convertRgbToJab_default = convertRgbToJab;
// src/jab/convertJabToRgb.js
var convertJabToRgb = (color) => convertXyz65ToRgb_default(convertJabToXyz65_default(color));
var convertJabToRgb_default = convertJabToRgb;
// src/jab/definition.js
var definition10 = {
mode: "jab",
channels: ["j", "a", "b", "alpha"],
parse: ["--jzazbz"],
serialize: "--jzazbz",
fromMode: {
rgb: convertRgbToJab_default,
xyz65: convertXyz65ToJab_default
},
toMode: {
rgb: convertJabToRgb_default,
xyz65: convertJabToXyz65_default
},
ranges: {
j: [0, 0.222],
a: [-0.109, 0.129],
b: [-0.185, 0.134]
},
interpolate: {
j: interpolatorLinear,
a: interpolatorLinear,
b: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default10 = definition10;
// src/jch/convertJabToJch.js
var convertJabToJch = ({ j, a, b, alpha }) => {
let c4 = Math.sqrt(a * a + b * b);
let res = {
mode: "jch",
j,
c: c4
};
if (c4) {
res.h = normalizeHue_default(Math.atan2(b, a) * 180 / Math.PI);
}
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertJabToJch_default = convertJabToJch;
// src/jch/convertJchToJab.js
var convertJchToJab = ({ j, c: c4, h, alpha }) => {
let res = {
mode: "jab",
j,
a: c4 ? c4 * Math.cos(h / 180 * Math.PI) : 0,
b: c4 ? c4 * Math.sin(h / 180 * Math.PI) : 0
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertJchToJab_default = convertJchToJab;
// src/jch/definition.js
var definition11 = {
mode: "jch",
parse: ["--jzczhz"],
serialize: "--jzczhz",
toMode: {
jab: convertJchToJab_default,
rgb: (c4) => convertJabToRgb_default(convertJchToJab_default(c4))
},
fromMode: {
rgb: (c4) => convertJabToJch_default(convertRgbToJab_default(c4)),
jab: convertJabToJch_default
},
channels: ["j", "c", "h", "alpha"],
ranges: {
j: [0, 0.221],
c: [0, 0.19],
h: [0, 360]
},
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
c: interpolatorLinear,
j: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueChroma
},
average: {
h: averageAngle
}
};
var definition_default11 = definition11;
// src/xyz50/constants.js
var k3 = Math.pow(29, 3) / Math.pow(3, 3);
var e3 = Math.pow(6, 3) / Math.pow(29, 3);
// src/lab/convertLabToXyz50.js
var fn4 = (v) => Math.pow(v, 3) > e3 ? Math.pow(v, 3) : (116 * v - 16) / k3;
var convertLabToXyz50 = ({ l, a, b, alpha }) => {
let fy = (l + 16) / 116;
let fx = a / 500 + fy;
let fz = fy - b / 200;
let res = {
mode: "xyz50",
x: fn4(fx) * D50.X,
y: fn4(fy) * D50.Y,
z: fn4(fz) * D50.Z
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertLabToXyz50_default = convertLabToXyz50;
// src/xyz50/convertXyz50ToRgb.js
var convertXyz50ToRgb = ({ x, y, z, alpha }) => {
let res = convertLrgbToRgb_default({
r: x * 3.1341359569958707 - y * 1.6173863321612538 - 0.4906619460083532 * z,
g: x * -0.978795502912089 + y * 1.916254567259524 + 0.03344273116131949 * z,
b: x * 0.07195537988411677 - y * 0.2289768264158322 + 1.405386058324125 * z
});
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz50ToRgb_default = convertXyz50ToRgb;
// src/lab/convertLabToRgb.js
var convertLabToRgb = (lab2) => convertXyz50ToRgb_default(convertLabToXyz50_default(lab2));
var convertLabToRgb_default = convertLabToRgb;
// src/xyz50/convertRgbToXyz50.js
var convertRgbToXyz50 = (rgb4) => {
let { r: r2, g, b, alpha } = convertRgbToLrgb_default(rgb4);
let res = {
mode: "xyz50",
x: 0.436065742824811 * r2 + 0.3851514688337912 * g + 0.14307845442264197 * b,
y: 0.22249319175623702 * r2 + 0.7168870538238823 * g + 0.06061979053616537 * b,
z: 0.013923904500943465 * r2 + 0.09708128566574634 * g + 0.7140993584005155 * b
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertRgbToXyz50_default = convertRgbToXyz50;
// src/lab/convertXyz50ToLab.js
var f2 = (value) => value > e3 ? Math.cbrt(value) : (k3 * value + 16) / 116;
var convertXyz50ToLab = ({ x, y, z, alpha }) => {
let f0 = f2(x / D50.X);
let f1 = f2(y / D50.Y);
let f22 = f2(z / D50.Z);
let res = {
mode: "lab",
l: 116 * f1 - 16,
a: 500 * (f0 - f1),
b: 200 * (f1 - f22)
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz50ToLab_default = convertXyz50ToLab;
// src/lab/convertRgbToLab.js
var convertRgbToLab = (rgb4) => {
let res = convertXyz50ToLab_default(convertRgbToXyz50_default(rgb4));
if (rgb4.r === rgb4.b && rgb4.b === rgb4.g) {
res.a = res.b = 0;
}
return res;
};
var convertRgbToLab_default = convertRgbToLab;
// src/lab/parseLab.js
function parseLab(color, parsed) {
if (!parsed || parsed[0] !== "lab") {
return void 0;
}
const res = { mode: "lab" };
const [, l, a, b, alpha] = parsed;
if (l.type === Tok.Hue || a.type === Tok.Hue || b.type === Tok.Hue) {
return void 0;
}
if (l.type !== Tok.None) {
res.l = l.value;
}
if (a.type !== Tok.None) {
res.a = a.type === Tok.Number ? a.value : a.value * 125 / 100;
}
if (b.type !== Tok.None) {
res.b = b.type === Tok.Number ? b.value : b.value * 125 / 100;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseLab_default = parseLab;
// src/lab/definition.js
var definition12 = {
mode: "lab",
toMode: {
xyz50: convertLabToXyz50_default,
rgb: convertLabToRgb_default
},
fromMode: {
xyz50: convertXyz50ToLab_default,
rgb: convertRgbToLab_default
},
channels: ["l", "a", "b", "alpha"],
ranges: {
l: [0, 100],
a: [-100, 100],
b: [-100, 100]
},
parse: [parseLab_default],
serialize: (c4) => `lab(${c4.l !== void 0 ? c4.l : "none"} ${c4.a !== void 0 ? c4.a : "none"} ${c4.b !== void 0 ? c4.b : "none"}${c4.alpha < 1 ? ` / ${c4.alpha}` : ""})`,
interpolate: {
l: interpolatorLinear,
a: interpolatorLinear,
b: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default12 = definition12;
// src/lab65/definition.js
var definition13 = {
...definition_default12,
mode: "lab65",
parse: ["--lab-d65"],
serialize: "--lab-d65",
toMode: {
xyz65: convertLab65ToXyz65_default,
rgb: convertLab65ToRgb_default
},
fromMode: {
xyz65: convertXyz65ToLab65_default,
rgb: convertRgbToLab65_default
},
ranges: {
l: [0, 100],
a: [-86.182, 98.234],
b: [-107.86, 94.477]
}
};
var definition_default13 = definition13;
// src/lch/parseLch.js
function parseLch(color, parsed) {
if (!parsed || parsed[0] !== "lch") {
return void 0;
}
const res = { mode: "lch" };
const [, l, c4, h, alpha] = parsed;
if (l.type !== Tok.None) {
if (l.type === Tok.Hue) {
return void 0;
}
res.l = l.value;
}
if (c4.type !== Tok.None) {
res.c = Math.max(
0,
c4.type === Tok.Number ? c4.value : c4.value * 150 / 100
);
}
if (h.type !== Tok.None) {
if (h.type === Tok.Percentage) {
return void 0;
}
res.h = h.value;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseLch_default = parseLch;
// src/lch/definition.js
var definition14 = {
mode: "lch",
toMode: {
lab: convertLchToLab_default,
rgb: (c4) => convertLabToRgb_default(convertLchToLab_default(c4))
},
fromMode: {
rgb: (c4) => convertLabToLch_default(convertRgbToLab_default(c4)),
lab: convertLabToLch_default
},
channels: ["l", "c", "h", "alpha"],
ranges: {
l: [0, 100],
c: [0, 150],
h: [0, 360]
},
parse: [parseLch_default],
serialize: (c4) => `lch(${c4.l !== void 0 ? c4.l : "none"} ${c4.c !== void 0 ? c4.c : "none"} ${c4.h || 0}${c4.alpha < 1 ? ` / ${c4.alpha}` : ""})`,
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
c: interpolatorLinear,
l: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueChroma
},
average: {
h: averageAngle
}
};
var definition_default14 = definition14;
// src/lch65/definition.js
var definition15 = {
...definition_default14,
mode: "lch65",
parse: ["--lch-d65"],
serialize: "--lch-d65",
toMode: {
lab65: (c4) => convertLchToLab_default(c4, "lab65"),
rgb: (c4) => convertLab65ToRgb_default(convertLchToLab_default(c4, "lab65"))
},
fromMode: {
rgb: (c4) => convertLabToLch_default(convertRgbToLab65_default(c4), "lch65"),
lab65: (c4) => convertLabToLch_default(c4, "lch65")
},
ranges: {
l: [0, 100],
c: [0, 133.807],
h: [0, 360]
}
};
var definition_default15 = definition15;
// src/lchuv/convertLuvToLchuv.js
var convertLuvToLchuv = ({ l, u, v, alpha }) => {
let c4 = Math.sqrt(u * u + v * v);
let res = {
mode: "lchuv",
l,
c: c4
};
if (c4) {
res.h = normalizeHue_default(Math.atan2(v, u) * 180 / Math.PI);
}
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertLuvToLchuv_default = convertLuvToLchuv;
// src/lchuv/convertLchuvToLuv.js
var convertLchuvToLuv = ({ l, c: c4, h, alpha }) => {
let res = {
mode: "luv",
l,
u: c4 ? c4 * Math.cos(h / 180 * Math.PI) : 0,
v: c4 ? c4 * Math.sin(h / 180 * Math.PI) : 0
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertLchuvToLuv_default = convertLchuvToLuv;
// src/luv/convertXyz50ToLuv.js
var u_fn = (x, y, z) => 4 * x / (x + 15 * y + 3 * z);
var v_fn = (x, y, z) => 9 * y / (x + 15 * y + 3 * z);
var un = u_fn(D50.X, D50.Y, D50.Z);
var vn = v_fn(D50.X, D50.Y, D50.Z);
var l_fn = (value) => value <= e3 ? k3 * value : 116 * Math.cbrt(value) - 16;
var convertXyz50ToLuv = ({ x, y, z, alpha }) => {
let l = l_fn(y / D50.Y);
let u = u_fn(x, y, z);
let v = v_fn(x, y, z);
if (!isFinite(u) || !isFinite(v)) {
l = u = v = 0;
} else {
u = 13 * l * (u - un);
v = 13 * l * (v - vn);
}
let res = {
mode: "luv",
l,
u,
v
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz50ToLuv_default = convertXyz50ToLuv;
// src/luv/convertLuvToXyz50.js
var u_fn2 = (x, y, z) => 4 * x / (x + 15 * y + 3 * z);
var v_fn2 = (x, y, z) => 9 * y / (x + 15 * y + 3 * z);
var un2 = u_fn2(D50.X, D50.Y, D50.Z);
var vn2 = v_fn2(D50.X, D50.Y, D50.Z);
var convertLuvToXyz50 = ({ l, u, v, alpha }) => {
let up = u / (13 * l) + un2;
let vp = v / (13 * l) + vn2;
let y = D50.Y * (l <= 8 ? l / k3 : Math.pow((l + 16) / 116, 3));
let x = y * (9 * up) / (4 * vp);
let z = y * (12 - 3 * up - 20 * vp) / (4 * vp);
let res = { mode: "xyz50", x, y, z };
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertLuvToXyz50_default = convertLuvToXyz50;
// src/lchuv/definition.js
var convertRgbToLchuv = (rgb4) => convertLuvToLchuv_default(convertXyz50ToLuv_default(convertRgbToXyz50_default(rgb4)));
var convertLchuvToRgb = (lchuv2) => convertXyz50ToRgb_default(convertLuvToXyz50_default(convertLchuvToLuv_default(lchuv2)));
var definition16 = {
mode: "lchuv",
toMode: {
luv: convertLchuvToLuv_default,
rgb: convertLchuvToRgb
},
fromMode: {
rgb: convertRgbToLchuv,
luv: convertLuvToLchuv_default
},
channels: ["l", "c", "h", "alpha"],
parse: ["--lchuv"],
serialize: "--lchuv",
ranges: {
l: [0, 100],
c: [0, 176.956],
h: [0, 360]
},
interpolate: {
h: { use: interpolatorLinear, fixup: fixupHueShorter },
c: interpolatorLinear,
l: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
},
difference: {
h: differenceHueChroma
},
average: {
h: averageAngle
}
};
var definition_default16 = definition16;
// src/lrgb/definition.js
var definition17 = {
...definition_default,
mode: "lrgb",
toMode: {
rgb: convertLrgbToRgb_default
},
fromMode: {
rgb: convertRgbToLrgb_default
},
parse: ["srgb-linear"],
serialize: "srgb-linear"
};
var definition_default17 = definition17;
// src/luv/definition.js
var definition18 = {
mode: "luv",
toMode: {
xyz50: convertLuvToXyz50_default,
rgb: (luv2) => convertXyz50ToRgb_default(convertLuvToXyz50_default(luv2))
},
fromMode: {
xyz50: convertXyz50ToLuv_default,
rgb: (rgb4) => convertXyz50ToLuv_default(convertRgbToXyz50_default(rgb4))
},
channels: ["l", "u", "v", "alpha"],
parse: ["--luv"],
serialize: "--luv",
ranges: {
l: [0, 100],
u: [-84.936, 175.042],
v: [-125.882, 87.243]
},
interpolate: {
l: interpolatorLinear,
u: interpolatorLinear,
v: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default18 = definition18;
// src/oklab/convertLrgbToOklab.js
var convertLrgbToOklab = ({ r: r2, g, b, alpha }) => {
let L = Math.cbrt(
0.41222147079999993 * r2 + 0.5363325363 * g + 0.0514459929 * b
);
let M2 = Math.cbrt(
0.2119034981999999 * r2 + 0.6806995450999999 * g + 0.1073969566 * b
);
let S = Math.cbrt(
0.08830246189999998 * r2 + 0.2817188376 * g + 0.6299787005000002 * b
);
let res = {
mode: "oklab",
l: 0.2104542553 * L + 0.793617785 * M2 - 0.0040720468 * S,
a: 1.9779984951 * L - 2.428592205 * M2 + 0.4505937099 * S,
b: 0.0259040371 * L + 0.7827717662 * M2 - 0.808675766 * S
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertLrgbToOklab_default = convertLrgbToOklab;
// src/oklab/convertRgbToOklab.js
var convertRgbToOklab = (rgb4) => {
let res = convertLrgbToOklab_default(convertRgbToLrgb_default(rgb4));
if (rgb4.r === rgb4.b && rgb4.b === rgb4.g) {
res.a = res.b = 0;
}
return res;
};
var convertRgbToOklab_default = convertRgbToOklab;
// src/oklab/convertOklabToLrgb.js
var convertOklabToLrgb = ({ l, a, b, alpha }) => {
let L = Math.pow(
l * 0.9999999984505198 + 0.39633779217376786 * a + 0.2158037580607588 * b,
3
);
let M2 = Math.pow(
l * 1.0000000088817609 - 0.10556134232365635 * a - 0.06385417477170591 * b,
3
);
let S = Math.pow(
l * 1.0000000546724108 - 0.08948418209496575 * a - 1.2914855378640917 * b,
3
);
let res = {
mode: "lrgb",
r: 4.076741661347994 * L - 3.307711590408193 * M2 + 0.230969928729428 * S,
g: -1.2684380040921763 * L + 2.6097574006633715 * M2 - 0.3413193963102197 * S,
b: -0.004196086541837188 * L - 0.7034186144594493 * M2 + 1.7076147009309444 * S
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertOklabToLrgb_default = convertOklabToLrgb;
// src/oklab/convertOklabToRgb.js
var convertOklabToRgb = (c4) => convertLrgbToRgb_default(convertOklabToLrgb_default(c4));
var convertOklabToRgb_default = convertOklabToRgb;
// src/okhsl/helpers.js
function toe(x) {
const k_1 = 0.206;
const k_2 = 0.03;
const k_3 = (1 + k_1) / (1 + k_2);
return 0.5 * (k_3 * x - k_1 + Math.sqrt((k_3 * x - k_1) * (k_3 * x - k_1) + 4 * k_2 * k_3 * x));
}
function toe_inv(x) {
const k_1 = 0.206;
const k_2 = 0.03;
const k_3 = (1 + k_1) / (1 + k_2);
return (x * x + k_1 * x) / (k_3 * (x + k_2));
}
function compute_max_saturation(a, b) {
let k0, k1, k22, k32, k4, wl, wm, ws;
if (-1.88170328 * a - 0.80936493 * b > 1) {
k0 = 1.19086277;
k1 = 1.76576728;
k22 = 0.59662641;
k32 = 0.75515197;
k4 = 0.56771245;
wl = 4.0767416621;
wm = -3.3077115913;
ws = 0.2309699292;
} else if (1.81444104 * a - 1.19445276 * b > 1) {
k0 = 0.73956515;
k1 = -0.45954404;
k22 = 0.08285427;
k32 = 0.1254107;
k4 = 0.14503204;
wl = -1.2684380046;
wm = 2.6097574011;
ws = -0.3413193965;
} else {
k0 = 1.35733652;
k1 = -915799e-8;
k22 = -1.1513021;
k32 = -0.50559606;
k4 = 692167e-8;
wl = -0.0041960863;
wm = -0.7034186147;
ws = 1.707614701;
}
let S = k0 + k1 * a + k22 * b + k32 * a * a + k4 * a * b;
let k_l = 0.3963377774 * a + 0.2158037573 * b;
let k_m = -0.1055613458 * a - 0.0638541728 * b;
let k_s = -0.0894841775 * a - 1.291485548 * b;
{
let l_ = 1 + S * k_l;
let m_ = 1 + S * k_m;
let s_ = 1 + S * k_s;
let l = l_ * l_ * l_;
let m = m_ * m_ * m_;
let s = s_ * s_ * s_;
let l_dS = 3 * k_l * l_ * l_;
let m_dS = 3 * k_m * m_ * m_;
let s_dS = 3 * k_s * s_ * s_;
let l_dS2 = 6 * k_l * k_l * l_;
let m_dS2 = 6 * k_m * k_m * m_;
let s_dS2 = 6 * k_s * k_s * s_;
let f3 = wl * l + wm * m + ws * s;
let f1 = wl * l_dS + wm * m_dS + ws * s_dS;
let f22 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2;
S = S - f3 * f1 / (f1 * f1 - 0.5 * f3 * f22);
}
return S;
}
function find_cusp(a, b) {
let S_cusp = compute_max_saturation(a, b);
let rgb4 = convertOklabToLrgb_default({ l: 1, a: S_cusp * a, b: S_cusp * b });
let L_cusp = Math.cbrt(1 / Math.max(rgb4.r, rgb4.g, rgb4.b));
let C_cusp = L_cusp * S_cusp;
return [L_cusp, C_cusp];
}
function find_gamut_intersection(a, b, L1, C1, L0, cusp = null) {
if (!cusp) {
cusp = find_cusp(a, b);
}
let t;
if ((L1 - L0) * cusp[1] - (cusp[0] - L0) * C1 <= 0) {
t = cusp[1] * L0 / (C1 * cusp[0] + cusp[1] * (L0 - L1));
} else {
t = cusp[1] * (L0 - 1) / (C1 * (cusp[0] - 1) + cusp[1] * (L0 - L1));
{
let dL = L1 - L0;
let dC = C1;
let k_l = 0.3963377774 * a + 0.2158037573 * b;
let k_m = -0.1055613458 * a - 0.0638541728 * b;
let k_s = -0.0894841775 * a - 1.291485548 * b;
let l_dt = dL + dC * k_l;
let m_dt = dL + dC * k_m;
let s_dt = dL + dC * k_s;
{
let L = L0 * (1 - t) + t * L1;
let C = t * C1;
let l_ = L + C * k_l;
let m_ = L + C * k_m;
let s_ = L + C * k_s;
let l = l_ * l_ * l_;
let m = m_ * m_ * m_;
let s = s_ * s_ * s_;
let ldt = 3 * l_dt * l_ * l_;
let mdt = 3 * m_dt * m_ * m_;
let sdt = 3 * s_dt * s_ * s_;
let ldt2 = 6 * l_dt * l_dt * l_;
let mdt2 = 6 * m_dt * m_dt * m_;
let sdt2 = 6 * s_dt * s_dt * s_;
let r2 = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s - 1;
let r1 = 4.0767416621 * ldt - 3.3077115913 * mdt + 0.2309699292 * sdt;
let r22 = 4.0767416621 * ldt2 - 3.3077115913 * mdt2 + 0.2309699292 * sdt2;
let u_r = r1 / (r1 * r1 - 0.5 * r2 * r22);
let t_r = -r2 * u_r;
let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s - 1;
let g1 = -1.2684380046 * ldt + 2.6097574011 * mdt - 0.3413193965 * sdt;
let g2 = -1.2684380046 * ldt2 + 2.6097574011 * mdt2 - 0.3413193965 * sdt2;
let u_g = g1 / (g1 * g1 - 0.5 * g * g2);
let t_g = -g * u_g;
let b2 = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s - 1;
let b1 = -0.0041960863 * ldt - 0.7034186147 * mdt + 1.707614701 * sdt;
let b22 = -0.0041960863 * ldt2 - 0.7034186147 * mdt2 + 1.707614701 * sdt2;
let u_b = b1 / (b1 * b1 - 0.5 * b2 * b22);
let t_b = -b2 * u_b;
t_r = u_r >= 0 ? t_r : 1e6;
t_g = u_g >= 0 ? t_g : 1e6;
t_b = u_b >= 0 ? t_b : 1e6;
t += Math.min(t_r, Math.min(t_g, t_b));
}
}
}
return t;
}
function get_ST_max(a_, b_, cusp = null) {
if (!cusp) {
cusp = find_cusp(a_, b_);
}
let L = cusp[0];
let C = cusp[1];
return [C / L, C / (1 - L)];
}
function get_Cs(L, a_, b_) {
let cusp = find_cusp(a_, b_);
let C_max = find_gamut_intersection(a_, b_, L, 1, L, cusp);
let ST_max = get_ST_max(a_, b_, cusp);
let S_mid = 0.11516993 + 1 / (7.4477897 + 4.1590124 * b_ + a_ * (-2.19557347 + 1.75198401 * b_ + a_ * (-2.13704948 - 10.02301043 * b_ + a_ * (-4.24894561 + 5.38770819 * b_ + 4.69891013 * a_))));
let T_mid = 0.11239642 + 1 / (1.6132032 - 0.68124379 * b_ + a_ * (0.40370612 + 0.90148123 * b_ + a_ * (-0.27087943 + 0.6122399 * b_ + a_ * (299215e-8 - 0.45399568 * b_ - 0.14661872 * a_))));
let k4 = C_max / Math.min(L * ST_max[0], (1 - L) * ST_max[1]);
let C_a = L * S_mid;
let C_b = (1 - L) * T_mid;
let C_mid = 0.9 * k4 * Math.sqrt(
Math.sqrt(
1 / (1 / (C_a * C_a * C_a * C_a) + 1 / (C_b * C_b * C_b * C_b))
)
);
C_a = L * 0.4;
C_b = (1 - L) * 0.8;
let C_0 = Math.sqrt(1 / (1 / (C_a * C_a) + 1 / (C_b * C_b)));
return [C_0, C_mid, C_max];
}
// src/okhsl/convertOklabToOkhsl.js
function convertOklabToOkhsl(lab2) {
const ret = { mode: "okhsl", l: toe(lab2.l) };
if (lab2.alpha !== void 0) {
ret.alpha = lab2.alpha;
}
let c4 = Math.sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
if (!c4) {
ret.s = 0;
return ret;
}
let [C_0, C_mid, C_max] = get_Cs(lab2.l, lab2.a / c4, lab2.b / c4);
let s;
if (c4 < C_mid) {
let k_0 = 0;
let k_1 = 0.8 * C_0;
let k_2 = 1 - k_1 / C_mid;
let t = (c4 - k_0) / (k_1 + k_2 * (c4 - k_0));
s = t * 0.8;
} else {
let k_0 = C_mid;
let k_1 = 0.2 * C_mid * C_mid * 1.25 * 1.25 / C_0;
let k_2 = 1 - k_1 / (C_max - C_mid);
let t = (c4 - k_0) / (k_1 + k_2 * (c4 - k_0));
s = 0.8 + 0.2 * t;
}
if (s) {
ret.s = s;
ret.h = normalizeHue_default(Math.atan2(lab2.b, lab2.a) * 180 / Math.PI);
}
return ret;
}
// src/okhsl/convertOkhslToOklab.js
function convertOkhslToOklab(hsl2) {
let l = toe_inv(hsl2.l);
const ret = { mode: "oklab", l };
if (hsl2.alpha !== void 0) {
ret.alpha = hsl2.alpha;
}
if (!hsl2.s || hsl2.l === 1) {
ret.a = ret.b = 0;
return ret;
}
let a_ = Math.cos(hsl2.h / 180 * Math.PI);
let b_ = Math.sin(hsl2.h / 180 * Math.PI);
let [C_0, C_mid, C_max] = get_Cs(l, a_, b_);
let t, k_0, k_1, k_2;
if (hsl2.s < 0.8) {
t = 1.25 * hsl2.s;
k_0 = 0;
k_1 = 0.8 * C_0;
k_2 = 1 - k_1 / C_mid;
} else {
t = 5 * (hsl2.s - 0.8);
k_0 = C_mid;
k_1 = 0.2 * C_mid * C_mid * 1.25 * 1.25 / C_0;
k_2 = 1 - k_1 / (C_max - C_mid);
}
let C = k_0 + t * k_1 / (1 - k_2 * t);
ret.a = C * a_;
ret.b = C * b_;
return ret;
}
// src/okhsl/modeOkhsl.js
var modeOkhsl = {
...definition_default7,
mode: "okhsl",
channels: ["h", "s", "l", "alpha"],
parse: ["--okhsl"],
serialize: "--okhsl",
fromMode: {
oklab: convertOklabToOkhsl,
rgb: (c4) => convertOklabToOkhsl(convertRgbToOklab_default(c4))
},
toMode: {
oklab: convertOkhslToOklab,
rgb: (c4) => convertOklabToRgb_default(convertOkhslToOklab(c4))
}
};
var modeOkhsl_default = modeOkhsl;
// src/okhsv/convertOklabToOkhsv.js
function convertOklabToOkhsv(lab2) {
let c4 = Math.sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
let l = lab2.l;
let a_ = c4 ? lab2.a / c4 : 1;
let b_ = c4 ? lab2.b / c4 : 1;
let [S_max, T] = get_ST_max(a_, b_);
let S_0 = 0.5;
let k4 = 1 - S_0 / S_max;
let t = T / (c4 + l * T);
let L_v = t * l;
let C_v = t * c4;
let L_vt = toe_inv(L_v);
let C_vt = C_v * L_vt / L_v;
let rgb_scale = convertOklabToLrgb_default({ l: L_vt, a: a_ * C_vt, b: b_ * C_vt });
let scale_L = Math.cbrt(
1 / Math.max(rgb_scale.r, rgb_scale.g, rgb_scale.b, 0)
);
l = l / scale_L;
c4 = c4 / scale_L * toe(l) / l;
l = toe(l);
const ret = {
mode: "okhsv",
s: c4 ? (S_0 + T) * C_v / (T * S_0 + T * k4 * C_v) : 0,
v: l ? l / L_v : 0
};
if (ret.s) {
ret.h = normalizeHue_default(Math.atan2(lab2.b, lab2.a) * 180 / Math.PI);
}
if (lab2.alpha !== void 0) {
ret.alpha = lab2.alpha;
}
return ret;
}
// src/okhsv/convertOkhsvToOklab.js
function convertOkhsvToOklab(hsv2) {
const ret = { mode: "oklab" };
if (hsv2.alpha !== void 0) {
ret.alpha = hsv2.alpha;
}
const h = hsv2.h || 0;
const a_ = Math.cos(h / 180 * Math.PI);
const b_ = Math.sin(h / 180 * Math.PI);
const [S_max, T] = get_ST_max(a_, b_);
const S_0 = 0.5;
const k4 = 1 - S_0 / S_max;
const L_v = 1 - hsv2.s * S_0 / (S_0 + T - T * k4 * hsv2.s);
const C_v = hsv2.s * T * S_0 / (S_0 + T - T * k4 * hsv2.s);
const L_vt = toe_inv(L_v);
const C_vt = C_v * L_vt / L_v;
const rgb_scale = convertOklabToLrgb_default({
l: L_vt,
a: a_ * C_vt,
b: b_ * C_vt
});
const scale_L = Math.cbrt(
1 / Math.max(rgb_scale.r, rgb_scale.g, rgb_scale.b, 0)
);
const L_new = toe_inv(hsv2.v * L_v);
const C = C_v * L_new / L_v;
ret.l = L_new * scale_L;
ret.a = C * a_ * scale_L;
ret.b = C * b_ * scale_L;
return ret;
}
// src/okhsv/modeOkhsv.js
var modeOkhsv = {
...definition_default8,
mode: "okhsv",
channels: ["h", "s", "v", "alpha"],
parse: ["--okhsv"],
serialize: "--okhsv",
fromMode: {
oklab: convertOklabToOkhsv,
rgb: (c4) => convertOklabToOkhsv(convertRgbToOklab_default(c4))
},
toMode: {
oklab: convertOkhsvToOklab,
rgb: (c4) => convertOklabToRgb_default(convertOkhsvToOklab(c4))
}
};
var modeOkhsv_default = modeOkhsv;
// src/oklab/parseOklab.js
function parseOklab(color, parsed) {
if (!parsed || parsed[0] !== "oklab") {
return void 0;
}
const res = { mode: "oklab" };
const [, l, a, b, alpha] = parsed;
if (l.type === Tok.Hue || a.type === Tok.Hue || b.type === Tok.Hue) {
return void 0;
}
if (l.type !== Tok.None) {
res.l = l.type === Tok.Number ? l.value : l.value / 100;
}
if (a.type !== Tok.None) {
res.a = a.type === Tok.Number ? a.value : a.value * 0.4 / 100;
}
if (b.type !== Tok.None) {
res.b = b.type === Tok.Number ? b.value : b.value * 0.4 / 100;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseOklab_default = parseOklab;
// src/oklab/definition.js
var definition19 = {
...definition_default12,
mode: "oklab",
toMode: {
lrgb: convertOklabToLrgb_default,
rgb: convertOklabToRgb_default
},
fromMode: {
lrgb: convertLrgbToOklab_default,
rgb: convertRgbToOklab_default
},
ranges: {
l: [0, 1],
a: [-0.4, 0.4],
b: [-0.4, 0.4]
},
parse: [parseOklab_default],
serialize: (c4) => `oklab(${c4.l !== void 0 ? c4.l : "none"} ${c4.a !== void 0 ? c4.a : "none"} ${c4.b !== void 0 ? c4.b : "none"}${c4.alpha < 1 ? ` / ${c4.alpha}` : ""})`
};
var definition_default19 = definition19;
// src/oklch/parseOklch.js
function parseOklch(color, parsed) {
if (!parsed || parsed[0] !== "oklch") {
return void 0;
}
const res = { mode: "oklch" };
const [, l, c4, h, alpha] = parsed;
if (l.type !== Tok.None) {
if (l.type === Tok.Hue) {
return void 0;
}
res.l = l.type === Tok.Number ? l.value : l.value / 100;
}
if (c4.type !== Tok.None) {
res.c = Math.max(
0,
c4.type === Tok.Number ? c4.value : c4.value * 0.4 / 100
);
}
if (h.type !== Tok.None) {
if (h.type === Tok.Percentage) {
return void 0;
}
res.h = h.value;
}
if (alpha.type !== Tok.None) {
res.alpha = alpha.type === Tok.Number ? alpha.value : alpha.value / 100;
}
return res;
}
var parseOklch_default = parseOklch;
// src/oklch/definition.js
var definition20 = {
...definition_default14,
mode: "oklch",
toMode: {
oklab: (c4) => convertLchToLab_default(c4, "oklab"),
rgb: (c4) => convertOklabToRgb_default(convertLchToLab_default(c4, "oklab"))
},
fromMode: {
rgb: (c4) => convertLabToLch_default(convertRgbToOklab_default(c4), "oklch"),
oklab: (c4) => convertLabToLch_default(c4, "oklch")
},
parse: [parseOklch_default],
serialize: (c4) => `oklch(${c4.l !== void 0 ? c4.l : "none"} ${c4.c !== void 0 ? c4.c : "none"} ${c4.h || 0}${c4.alpha < 1 ? ` / ${c4.alpha}` : ""})`,
ranges: {
l: [0, 1],
c: [0, 0.4],
h: [0, 360]
}
};
var definition_default20 = definition20;
// src/p3/convertP3ToXyz65.js
var convertP3ToXyz65 = (rgb4) => {
let { r: r2, g, b, alpha } = convertRgbToLrgb_default(rgb4);
let res = {
mode: "xyz65",
x: 0.486570948648216 * r2 + 0.265667693169093 * g + 0.1982172852343625 * b,
y: 0.2289745640697487 * r2 + 0.6917385218365062 * g + 0.079286914093745 * b,
z: 0 * r2 + 0.0451133818589026 * g + 1.043944368900976 * b
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertP3ToXyz65_default = convertP3ToXyz65;
// src/p3/convertXyz65ToP3.js
var convertXyz65ToP3 = ({ x, y, z, alpha }) => {
let res = convertLrgbToRgb_default(
{
r: x * 2.4934969119414263 - y * 0.9313836179191242 - 0.402710784450717 * z,
g: x * -0.8294889695615749 + y * 1.7626640603183465 + 0.0236246858419436 * z,
b: x * 0.0358458302437845 - y * 0.0761723892680418 + 0.9568845240076871 * z
},
"p3"
);
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToP3_default = convertXyz65ToP3;
// src/p3/definition.js
var definition21 = {
...definition_default,
mode: "p3",
parse: ["display-p3"],
serialize: "display-p3",
fromMode: {
rgb: (color) => convertXyz65ToP3_default(convertRgbToXyz65_default(color)),
xyz65: convertXyz65ToP3_default
},
toMode: {
rgb: (color) => convertXyz65ToRgb_default(convertP3ToXyz65_default(color)),
xyz65: convertP3ToXyz65_default
}
};
var definition_default21 = definition21;
// src/prophoto/convertXyz50ToProphoto.js
var gamma2 = (v) => {
let abs3 = Math.abs(v);
if (abs3 >= 1 / 512) {
return Math.sign(v) * Math.pow(abs3, 1 / 1.8);
}
return 16 * v;
};
var convertXyz50ToProphoto = ({ x, y, z, alpha }) => {
let res = {
mode: "prophoto",
r: gamma2(
x * 1.3457868816471585 - y * 0.2555720873797946 - 0.0511018649755453 * z
),
g: gamma2(
x * -0.5446307051249019 + y * 1.5082477428451466 + 0.0205274474364214 * z
),
b: gamma2(x * 0 + y * 0 + 1.2119675456389452 * z)
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz50ToProphoto_default = convertXyz50ToProphoto;
// src/prophoto/convertProphotoToXyz50.js
var linearize2 = (v) => {
let abs3 = Math.abs(v);
if (abs3 >= 16 / 512) {
return Math.sign(v) * Math.pow(abs3, 1.8);
}
return v / 16;
};
var convertProphotoToXyz50 = (prophoto2) => {
let r2 = linearize2(prophoto2.r);
let g = linearize2(prophoto2.g);
let b = linearize2(prophoto2.b);
let res = {
mode: "xyz50",
x: 0.7977666449006423 * r2 + 0.1351812974005331 * g + 0.0313477341283922 * b,
y: 0.2880748288194013 * r2 + 0.7118352342418731 * g + 899369387256e-16 * b,
z: 0 * r2 + 0 * g + 0.8251046025104602 * b
};
if (prophoto2.alpha !== void 0) {
res.alpha = prophoto2.alpha;
}
return res;
};
var convertProphotoToXyz50_default = convertProphotoToXyz50;
// src/prophoto/definition.js
var definition22 = {
...definition_default,
mode: "prophoto",
parse: ["prophoto-rgb"],
serialize: "prophoto-rgb",
fromMode: {
xyz50: convertXyz50ToProphoto_default,
rgb: (color) => convertXyz50ToProphoto_default(convertRgbToXyz50_default(color))
},
toMode: {
xyz50: convertProphotoToXyz50_default,
rgb: (color) => convertXyz50ToRgb_default(convertProphotoToXyz50_default(color))
}
};
var definition_default22 = definition22;
// src/rec2020/convertXyz65ToRec2020.js
var \u03B1 = 1.09929682680944;
var \u03B2 = 0.018053968510807;
var gamma3 = (v) => {
const abs3 = Math.abs(v);
if (abs3 > \u03B2) {
return (Math.sign(v) || 1) * (\u03B1 * Math.pow(abs3, 0.45) - (\u03B1 - 1));
}
return 4.5 * v;
};
var convertXyz65ToRec2020 = ({ x, y, z, alpha }) => {
let res = {
mode: "rec2020",
r: gamma3(
x * 1.7166511879712683 - y * 0.3556707837763925 - 0.2533662813736599 * z
),
g: gamma3(
x * -0.6666843518324893 + y * 1.6164812366349395 + 0.0157685458139111 * z
),
b: gamma3(
x * 0.0176398574453108 - y * 0.0427706132578085 + 0.9421031212354739 * z
)
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToRec2020_default = convertXyz65ToRec2020;
// src/rec2020/convertRec2020ToXyz65.js
var \u03B12 = 1.09929682680944;
var \u03B22 = 0.018053968510807;
var linearize3 = (v) => {
let abs3 = Math.abs(v);
if (abs3 < \u03B22 * 4.5) {
return v / 4.5;
}
return (Math.sign(v) || 1) * Math.pow((abs3 + \u03B12 - 1) / \u03B12, 1 / 0.45);
};
var convertRec2020ToXyz65 = (rec20202) => {
let r2 = linearize3(rec20202.r);
let g = linearize3(rec20202.g);
let b = linearize3(rec20202.b);
let res = {
mode: "xyz65",
x: 0.6369580483012911 * r2 + 0.1446169035862083 * g + 0.1688809751641721 * b,
y: 0.262700212011267 * r2 + 0.6779980715188708 * g + 0.059301716469862 * b,
z: 0 * r2 + 0.0280726930490874 * g + 1.0609850577107909 * b
};
if (rec20202.alpha !== void 0) {
res.alpha = rec20202.alpha;
}
return res;
};
var convertRec2020ToXyz65_default = convertRec2020ToXyz65;
// src/rec2020/definition.js
var definition23 = {
...definition_default,
mode: "rec2020",
fromMode: {
xyz65: convertXyz65ToRec2020_default,
rgb: (color) => convertXyz65ToRec2020_default(convertRgbToXyz65_default(color))
},
toMode: {
xyz65: convertRec2020ToXyz65_default,
rgb: (color) => convertXyz65ToRgb_default(convertRec2020ToXyz65_default(color))
},
parse: ["rec2020"],
serialize: "rec2020"
};
var definition_default23 = definition23;
// src/xyb/constants.js
var bias = 0.0037930732552754493;
var bias_cbrt = Math.cbrt(bias);
// src/xyb/convertRgbToXyb.js
var transfer = (v) => Math.cbrt(v) - bias_cbrt;
var convertRgbToXyb = (color) => {
const { r: r2, g, b, alpha } = convertRgbToLrgb_default(color);
const l = transfer(0.3 * r2 + 0.622 * g + 0.078 * b + bias);
const m = transfer(0.23 * r2 + 0.692 * g + 0.078 * b + bias);
const s = transfer(
0.2434226892454782 * r2 + 0.2047674442449682 * g + 0.5518098665095535 * b + bias
);
const res = {
mode: "xyb",
x: (l - m) / 2,
y: (l + m) / 2,
/* Apply default chroma from luma (subtract Y from B) */
b: s - (l + m) / 2
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertRgbToXyb_default = convertRgbToXyb;
// src/xyb/convertXybToRgb.js
var transfer2 = (v) => Math.pow(v + bias_cbrt, 3);
var convertXybToRgb = ({ x, y, b, alpha }) => {
const l = transfer2(x + y) - bias;
const m = transfer2(y - x) - bias;
const s = transfer2(b + y) - bias;
const res = convertLrgbToRgb_default({
r: 11.031566904639861 * l - 9.866943908131562 * m - 0.16462299650829934 * s,
g: -3.2541473810744237 * l + 4.418770377582723 * m - 0.16462299650829934 * s,
b: -3.6588512867136815 * l + 2.7129230459360922 * m + 1.9459282407775895 * s
});
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertXybToRgb_default = convertXybToRgb;
// src/xyb/definition.js
var definition24 = {
mode: "xyb",
channels: ["x", "y", "b", "alpha"],
parse: ["--xyb"],
serialize: "--xyb",
toMode: {
rgb: convertXybToRgb_default
},
fromMode: {
rgb: convertRgbToXyb_default
},
ranges: {
x: [-0.0154, 0.0281],
y: [0, 0.8453],
b: [-0.2778, 0.388]
},
interpolate: {
x: interpolatorLinear,
y: interpolatorLinear,
b: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default24 = definition24;
// src/xyz50/definition.js
var definition25 = {
mode: "xyz50",
parse: ["xyz-d50"],
serialize: "xyz-d50",
toMode: {
rgb: convertXyz50ToRgb_default,
lab: convertXyz50ToLab_default
},
fromMode: {
rgb: convertRgbToXyz50_default,
lab: convertLabToXyz50_default
},
channels: ["x", "y", "z", "alpha"],
ranges: {
x: [0, 0.964],
y: [0, 0.999],
z: [0, 0.825]
},
interpolate: {
x: interpolatorLinear,
y: interpolatorLinear,
z: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default25 = definition25;
// src/xyz65/convertXyz65ToXyz50.js
var convertXyz65ToXyz50 = (xyz652) => {
let { x, y, z, alpha } = xyz652;
let res = {
mode: "xyz50",
x: 1.0479298208405488 * x + 0.0229467933410191 * y - 0.0501922295431356 * z,
y: 0.0296278156881593 * x + 0.990434484573249 * y - 0.0170738250293851 * z,
z: -0.0092430581525912 * x + 0.0150551448965779 * y + 0.7518742899580008 * z
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz65ToXyz50_default = convertXyz65ToXyz50;
// src/xyz65/convertXyz50ToXyz65.js
var convertXyz50ToXyz65 = (xyz502) => {
let { x, y, z, alpha } = xyz502;
let res = {
mode: "xyz65",
x: 0.9554734527042182 * x - 0.0230985368742614 * y + 0.0632593086610217 * z,
y: -0.0283697069632081 * x + 1.0099954580058226 * y + 0.021041398966943 * z,
z: 0.0123140016883199 * x - 0.0205076964334779 * y + 1.3303659366080753 * z
};
if (alpha !== void 0) {
res.alpha = alpha;
}
return res;
};
var convertXyz50ToXyz65_default = convertXyz50ToXyz65;
// src/xyz65/definition.js
var definition26 = {
mode: "xyz65",
toMode: {
rgb: convertXyz65ToRgb_default,
xyz50: convertXyz65ToXyz50_default
},
fromMode: {
rgb: convertRgbToXyz65_default,
xyz50: convertXyz50ToXyz65_default
},
ranges: {
x: [0, 0.95],
y: [0, 1],
z: [0, 1.088]
},
channels: ["x", "y", "z", "alpha"],
parse: ["xyz", "xyz-d65"],
serialize: "xyz-d65",
interpolate: {
x: interpolatorLinear,
y: interpolatorLinear,
z: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default26 = definition26;
// src/yiq/convertRgbToYiq.js
var convertRgbToYiq = ({ r: r2, g, b, alpha }) => {
const res = {
mode: "yiq",
y: 0.29889531 * r2 + 0.58662247 * g + 0.11448223 * b,
i: 0.59597799 * r2 - 0.2741761 * g - 0.32180189 * b,
q: 0.21147017 * r2 - 0.52261711 * g + 0.31114694 * b
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertRgbToYiq_default = convertRgbToYiq;
// src/yiq/convertYiqToRgb.js
var convertYiqToRgb = ({ y, i, q, alpha }) => {
const res = {
mode: "rgb",
r: y + 0.95608445 * i + 0.6208885 * q,
g: y - 0.27137664 * i - 0.6486059 * q,
b: y - 1.10561724 * i + 1.70250126 * q
};
if (alpha !== void 0)
res.alpha = alpha;
return res;
};
var convertYiqToRgb_default = convertYiqToRgb;
// src/yiq/definition.js
var definition27 = {
mode: "yiq",
toMode: {
rgb: convertYiqToRgb_default
},
fromMode: {
rgb: convertRgbToYiq_default
},
channels: ["y", "i", "q", "alpha"],
parse: ["--yiq"],
serialize: "--yiq",
ranges: {
i: [-0.595, 0.595],
q: [-0.522, 0.522]
},
interpolate: {
y: interpolatorLinear,
i: interpolatorLinear,
q: interpolatorLinear,
alpha: { use: interpolatorLinear, fixup: fixupAlpha }
}
};
var definition_default27 = definition27;
// src/round.js
var r = (value, precision) => Math.round(value * (precision = Math.pow(10, precision))) / precision;
var round = (precision = 4) => (value) => typeof value === "number" ? r(value, precision) : value;
var round_default = round;
// src/formatter.js
var twoDecimals = round_default(2);
var clamp = (value) => Math.max(0, Math.min(1, value));
var fixup = (value) => Math.round(clamp(value) * 255);
var serializeHex = (color) => {
if (color === void 0) {
return void 0;
}
let r2 = fixup(color.r);
let g = fixup(color.g);
let b = fixup(color.b);
return "#" + (1 << 24 | r2 << 16 | g << 8 | b).toString(16).slice(1);
};
var serializeHex8 = (color) => {
if (color === void 0) {
return void 0;
}
let a = fixup(color.alpha !== void 0 ? color.alpha : 1);
return serializeHex(color) + (1 << 8 | a).toString(16).slice(1);
};
var serializeRgb = (color) => {
if (color === void 0) {
return void 0;
}
let r2 = color.r !== void 0 ? fixup(color.r) : "none";
let g = color.g !== void 0 ? fixup(color.g) : "none";
let b = color.b !== void 0 ? fixup(color.b) : "none";
if (color.alpha === void 0 || color.alpha === 1) {
return `rgb(${r2}, ${g}, ${b})`;
} else {
return `rgba(${r2}, ${g}, ${b}, ${twoDecimals(clamp(color.alpha))})`;
}
};
var serializeHsl = (color) => {
if (color === void 0) {
return void 0;
}
const h = twoDecimals(color.h || 0);
const s = color.s !== void 0 ? twoDecimals(clamp(color.s) * 100) + "%" : "none";
const l = color.l !== void 0 ? twoDecimals(clamp(color.l) * 100) + "%" : "none";
if (color.alpha === void 0 || color.alpha === 1) {
return `hsl(${h}, ${s}, ${l})`;
} else {
return `hsla(${h}, ${s}, ${l}, ${twoDecimals(clamp(color.alpha))})`;
}
};
var formatCss = (c4) => {
const color = prepare_default(c4);
if (!color) {
return void 0;
}
const def = getMode(color.mode);
if (!def.serialize || typeof def.serialize === "string") {
let res = `color(${def.serialize || `--${color.mode}`} `;
def.channels.forEach((ch, i) => {
if (ch !== "alpha") {
res += (i ? " " : "") + (color[ch] !== void 0 ? color[ch] : "none");
}
});
if (color.alpha !== void 0 && color.alpha < 1) {
res += ` / ${color.alpha}`;
}
return res + ")";
}
if (typeof def.serialize === "function") {
return def.serialize(color);
}
return void 0;
};
var formatHex = (c4) => serializeHex(converter_default("rgb")(c4));
var formatHex8 = (c4) => serializeHex8(converter_default("rgb")(c4));
var formatRgb = (c4) => serializeRgb(converter_default("rgb")(c4));
var formatHsl = (c4) => serializeHsl(converter_default("hsl")(c4));
// src/blend.js
var BLENDS = {
normal: (b, s) => s,
multiply: (b, s) => b * s,
screen: (b, s) => b + s - b * s,
"hard-light": (b, s) => s < 0.5 ? b * 2 * s : 2 * s * (1 - b) - 1,
overlay: (b, s) => b < 0.5 ? s * 2 * b : 2 * b * (1 - s) - 1,
darken: (b, s) => Math.min(b, s),
lighten: (b, s) => Math.max(b, s),
"color-dodge": (b, s) => b === 0 ? 0 : s === 1 ? 1 : Math.min(1, b / (1 - s)),
"color-burn": (b, s) => b === 1 ? 1 : s === 0 ? 0 : 1 - Math.min(1, (1 - b) / s),
"soft-light": (b, s) => s < 0.5 ? b - (1 - 2 * s) * b * (1 - b) : b + (2 * s - 1) * ((b < 0.25 ? ((16 * b - 12) * b + 4) * b : Math.sqrt(b)) - b),
difference: (b, s) => Math.abs(b - s),
exclusion: (b, s) => b + s - 2 * b * s
};
var blend = (colors, type = "normal", mode = "rgb") => {
let fn5 = typeof type === "function" ? type : BLENDS[type];
let conv = converter_default(mode);
let channels = getMode(mode).channels;
let converted = colors.map((c4) => {
let cc = conv(c4);
if (cc.alpha === void 0) {
cc.alpha = 1;
}
return cc;
});
return converted.reduce((b, s) => {
if (b === void 0)
return s;
let alpha = s.alpha + b.alpha * (1 - s.alpha);
return channels.reduce(
(res, ch) => {
if (ch !== "alpha") {
if (alpha === 0) {
res[ch] = 0;
} else {
res[ch] = s.alpha * (1 - b.alpha) * s[ch] + s.alpha * b.alpha * fn5(b[ch], s[ch]) + (1 - s.alpha) * b.alpha * b[ch];
res[ch] = Math.max(0, Math.min(1, res[ch] / alpha));
}
}
return res;
},
{ mode, alpha }
);
});
};
var blend_default = blend;
// src/random.js
var rand = ([min2, max]) => min2 + Math.random() * (max - min2);
var to_intervals = (constraints) => Object.keys(constraints).reduce((o, k4) => {
let v = constraints[k4];
o[k4] = Array.isArray(v) ? v : [v, v];
return o;
}, {});
var random = (mode = "rgb", constraints = {}) => {
let def = getMode(mode);
let limits = to_intervals(constraints);
return def.channels.reduce(
(res, ch) => {
if (limits.alpha || ch !== "alpha") {
res[ch] = rand(limits[ch] || def.ranges[ch]);
}
return res;
},
{ mode }
);
};
var random_default = random;
// src/map.js
var mapper = (fn5, mode = "rgb", preserve_mode = false) => {
let channels = mode ? getMode(mode).channels : null;
let conv = mode ? converter_default(mode) : prepare_default;
return (color) => {
let conv_color = conv(color);
if (!conv_color) {
return void 0;
}
let res = (channels || getMode(conv_color.mode).channels).reduce(
(res2, ch) => {
let v = fn5(conv_color[ch], ch, conv_color, mode);
if (v !== void 0 && !isNaN(v)) {
res2[ch] = v;
}
return res2;
},
{ mode: conv_color.mode }
);
if (!preserve_mode) {
return res;
}
let prep = prepare_default(color);
if (prep && prep.mode !== res.mode) {
return converter_default(prep.mode)(res);
}
return res;
};
};
var mapAlphaMultiply = (v, ch, c4) => {
if (ch !== "alpha") {
return (v || 0) * (c4.alpha !== void 0 ? c4.alpha : 1);
}
return v;
};
var mapAlphaDivide = (v, ch, c4) => {
if (ch !== "alpha" && c4.alpha !== 0) {
return (v || 0) / (c4.alpha !== void 0 ? c4.alpha : 1);
}
return v;
};
var mapTransferLinear = (slope = 1, intercept = 0) => (v, ch) => {
if (ch !== "alpha") {
return v * slope + intercept;
}
return v;
};
var mapTransferGamma = (amplitude = 1, exponent = 1, offset = 0) => (v, ch) => {
if (ch !== "alpha") {
return amplitude * Math.pow(v, exponent) + offset;
}
return v;
};
// src/util/normalizePositions.js
var normalizePositions = (arr) => {
if (arr[0] === void 0) {
arr[0] = 0;
}
if (arr[arr.length - 1] === void 0) {
arr[arr.length - 1] = 1;
}
let i = 1;
let j;
let from_idx;
let from_pos;
let inc;
while (i < arr.length) {
if (arr[i] === void 0) {
from_idx = i;
from_pos = arr[i - 1];
j = i;
while (arr[j] === void 0)
j++;
inc = (arr[j] - from_pos) / (j - i + 1);
while (i < j) {
arr[i] = from_pos + (i + 1 - from_idx) * inc;
i++;
}
} else if (arr[i] < arr[i - 1]) {
arr[i] = arr[i - 1];
}
i++;
}
return arr;
};
var normalizePositions_default = normalizePositions;
// src/easing/midpoint.js
var midpoint = (H = 0.5) => (t) => H <= 0 ? 1 : H >= 1 ? 0 : Math.pow(t, Math.log(0.5) / Math.log(H));
var midpoint_default = midpoint;
// src/interpolate/interpolate.js
var isfn2 = (o) => typeof o === "function";
var isobj = (o) => o && typeof o === "object";
var isnum = (o) => typeof o === "number";
var interpolate_fn = (colors, mode = "rgb", overrides, premap) => {
let def = getMode(mode);
let conv = converter_default(mode);
let conv_colors = [];
let positions = [];
let fns = {};
colors.forEach((val) => {
if (Array.isArray(val)) {
conv_colors.push(conv(val[0]));
positions.push(val[1]);
} else if (isnum(val) || isfn2(val)) {
fns[positions.length] = val;
} else {
conv_colors.push(conv(val));
positions.push(void 0);
}
});
normalizePositions_default(positions);
let fixed = def.channels.reduce((res, ch) => {
let ffn;
if (isobj(overrides) && isobj(overrides[ch]) && overrides[ch].fixup) {
ffn = overrides[ch].fixup;
} else if (isobj(def.interpolate[ch]) && def.interpolate[ch].fixup) {
ffn = def.interpolate[ch].fixup;
} else {
ffn = (v) => v;
}
res[ch] = ffn(conv_colors.map((color) => color[ch]));
return res;
}, {});
if (premap) {
let ccolors = conv_colors.map((color, idx) => {
return def.channels.reduce(
(c4, ch) => {
c4[ch] = fixed[ch][idx];
return c4;
},
{ mode }
);
});
fixed = def.channels.reduce((res, ch) => {
res[ch] = ccolors.map((c4) => {
let v = premap(c4[ch], ch, c4, mode);
return isNaN(v) ? void 0 : v;
});
return res;
}, {});
}
let interpolators = def.channels.reduce((res, ch) => {
let ifn;
if (isfn2(overrides)) {
ifn = overrides;
} else if (isobj(overrides) && isfn2(overrides[ch])) {
ifn = overrides[ch];
} else if (isobj(overrides) && isobj(overrides[ch]) && overrides[ch].use) {
ifn = overrides[ch].use;
} else if (isfn2(def.interpolate[ch])) {
ifn = def.interpolate[ch];
} else if (isobj(def.interpolate[ch])) {
ifn = def.interpolate[ch].use;
}
res[ch] = ifn(fixed[ch]);
return res;
}, {});
let n3 = conv_colors.length - 1;
return (t) => {
t = Math.min(Math.max(0, t), 1);
if (t <= positions[0]) {
return conv_colors[0];
}
if (t > positions[n3]) {
return conv_colors[n3];
}
let idx = 0;
while (positions[idx] < t)
idx++;
let start = positions[idx - 1];
let delta = positions[idx] - start;
let P = (t - start) / delta;
let fn5 = fns[idx] || fns[0];
if (fn5 !== void 0) {
if (isnum(fn5)) {
fn5 = midpoint_default((fn5 - start) / delta);
}
P = fn5(P);
}
let t0 = (idx - 1 + P) / n3;
return def.channels.reduce(
(res, channel) => {
let val = interpolators[channel](t0);
if (val !== void 0) {
res[channel] = val;
}
return res;
},
{ mode }
);
};
};
var interpolate = (colors, mode = "rgb", overrides) => interpolate_fn(colors, mode, overrides);
var interpolateWith = (premap, postmap) => (colors, mode = "rgb", overrides) => {
let post = postmap ? mapper(postmap, mode) : void 0;
let it = interpolate_fn(colors, mode, overrides, premap);
return post ? (t) => post(it(t)) : it;
};
var interpolateWithPremultipliedAlpha = interpolateWith(
mapAlphaMultiply,
mapAlphaDivide
);
// src/interpolate/splineBasis.js
var mod = (v, l) => (v + l) % l;
var bspline = (Vim2, Vim1, Vi, Vip1, t) => {
let t2 = t * t;
let t3 = t2 * t;
return ((1 - 3 * t + 3 * t2 - t3) * Vim2 + (4 - 6 * t2 + 3 * t3) * Vim1 + (1 + 3 * t + 3 * t2 - 3 * t3) * Vi + t3 * Vip1) / 6;
};
var interpolatorSplineBasis = (arr) => (t) => {
let classes = arr.length - 1;
let i = t >= 1 ? classes - 1 : Math.max(0, Math.floor(t * classes));
return bspline(
i > 0 ? arr[i - 1] : 2 * arr[i] - arr[i + 1],
arr[i],
arr[i + 1],
i < classes - 1 ? arr[i + 2] : 2 * arr[i + 1] - arr[i],
(t - i / classes) * classes
);
};
var interpolatorSplineBasisClosed = (arr) => (t) => {
const classes = arr.length - 1;
const i = Math.floor(t * classes);
return bspline(
arr[mod(i - 1, arr.length)],
arr[mod(i, arr.length)],
arr[mod(i + 1, arr.length)],
arr[mod(i + 2, arr.length)],
(t - i / classes) * classes
);
};
// src/interpolate/splineNatural.js
var solve = (v) => {
let i;
let n3 = v.length - 1;
let c4 = new Array(n3);
let _v = new Array(n3);
let sol = new Array(n3);
c4[1] = 1 / 4;
_v[1] = (6 * v[1] - v[0]) / 4;
for (i = 2; i < n3; ++i) {
c4[i] = 1 / (4 - c4[i - 1]);
_v[i] = (6 * v[i] - (i == n3 - 1 ? v[n3] : 0) - _v[i - 1]) * c4[i];
}
sol[0] = v[0];
sol[n3] = v[n3];
if (n3 - 1 > 0) {
sol[n3 - 1] = _v[n3 - 1];
}
for (i = n3 - 2; i > 0; --i) {
sol[i] = _v[i] - c4[i] * sol[i + 1];
}
return sol;
};
var interpolatorSplineNatural = (arr) => interpolatorSplineBasis(solve(arr));
var interpolatorSplineNaturalClosed = (arr) => interpolatorSplineBasisClosed(solve(arr));
// src/interpolate/splineMonotone.js
var sgn = Math.sign;
var min = Math.min;
var abs2 = Math.abs;
var mono = (arr) => {
let n3 = arr.length - 1;
let s = [];
let p4 = [];
let yp = [];
for (let i = 0; i < n3; i++) {
s.push((arr[i + 1] - arr[i]) * n3);
p4.push(i > 0 ? 0.5 * (arr[i + 1] - arr[i - 1]) * n3 : void 0);
yp.push(
i > 0 ? (sgn(s[i - 1]) + sgn(s[i])) * min(abs2(s[i - 1]), abs2(s[i]), 0.5 * abs2(p4[i])) : void 0
);
}
return [s, p4, yp];
};
var interpolator = (arr, yp, s) => {
let n3 = arr.length - 1;
let n22 = n3 * n3;
return (t) => {
let i;
if (t >= 1) {
i = n3 - 1;
} else {
i = Math.max(0, Math.floor(t * n3));
}
let t1 = t - i / n3;
let t2 = t1 * t1;
let t3 = t2 * t1;
return (yp[i] + yp[i + 1] - 2 * s[i]) * n22 * t3 + (3 * s[i] - 2 * yp[i] - yp[i + 1]) * n3 * t2 + yp[i] * t1 + arr[i];
};
};
var interpolatorSplineMonotone = (arr) => {
if (arr.length < 3) {
return interpolatorLinear(arr);
}
let n3 = arr.length - 1;
let [s, , yp] = mono(arr);
yp[0] = s[0];
yp[n3] = s[n3 - 1];
return interpolator(arr, yp, s);
};
var interpolatorSplineMonotone2 = (arr) => {
if (arr.length < 3) {
return interpolatorLinear(arr);
}
let n3 = arr.length - 1;
let [s, p4, yp] = mono(arr);
p4[0] = (arr[1] * 2 - arr[0] * 1.5 - arr[2] * 0.5) * n3;
p4[n3] = (arr[n3] * 1.5 - arr[n3 - 1] * 2 + arr[n3 - 2] * 0.5) * n3;
yp[0] = p4[0] * s[0] <= 0 ? 0 : abs2(p4[0]) > 2 * abs2(s[0]) ? 2 * s[0] : p4[0];
yp[n3] = p4[n3] * s[n3 - 1] <= 0 ? 0 : abs2(p4[n3]) > 2 * abs2(s[n3 - 1]) ? 2 * s[n3 - 1] : p4[n3];
return interpolator(arr, yp, s);
};
var interpolatorSplineMonotoneClosed = (arr) => {
let n3 = arr.length - 1;
let [s, p4, yp] = mono(arr);
p4[0] = 0.5 * (arr[1] - arr[n3]) * n3;
p4[n3] = 0.5 * (arr[0] - arr[n3 - 1]) * n3;
let s_m1 = (arr[0] - arr[n3]) * n3;
let s_n = s_m1;
yp[0] = (sgn(s_m1) + sgn(s[0])) * min(abs2(s_m1), abs2(s[0]), 0.5 * abs2(p4[0]));
yp[n3] = (sgn(s[n3 - 1]) + sgn(s_n)) * min(abs2(s[n3 - 1]), abs2(s_n), 0.5 * abs2(p4[n3]));
return interpolator(arr, yp, s);
};
// src/easing/gamma.js
var gamma4 = (\u03B3 = 1) => \u03B3 === 1 ? (t) => t : (t) => Math.pow(t, \u03B3);
var gamma_default = gamma4;
// src/samples.js
var samples = (n3 = 2, \u03B3 = 1) => {
let ease = gamma_default(\u03B3);
if (n3 < 2) {
return n3 < 1 ? [] : [ease(0.5)];
}
let res = [];
for (let i = 0; i < n3; i++) {
res.push(ease(i / (n3 - 1)));
}
return res;
};
var samples_default = samples;
// src/clamp.js
var rgb = converter_default("rgb");
var fixup_rgb = (c4) => {
const res = {
mode: c4.mode,
r: Math.max(0, Math.min(c4.r, 1)),
g: Math.max(0, Math.min(c4.g, 1)),
b: Math.max(0, Math.min(c4.b, 1))
};
if (c4.alpha !== void 0) {
res.alpha = c4.alpha;
}
return res;
};
var to_displayable_srgb = (c4) => fixup_rgb(rgb(c4));
var inrange_rgb = (c4) => {
return c4 !== void 0 && c4.r >= 0 && c4.r <= 1 && c4.g >= 0 && c4.g <= 1 && c4.b >= 0 && c4.b <= 1;
};
function displayable(color) {
return inrange_rgb(rgb(color));
}
function inGamut(mode = "rgb") {
const { gamut } = getMode(mode);
if (!gamut) {
return (color) => true;
}
const conv = converter_default(typeof gamut === "string" ? gamut : mode);
return (color) => inrange_rgb(conv(color));
}
function clampRgb(color) {
color = prepare_default(color);
if (color === void 0 || displayable(color))
return color;
let conv = converter_default(color.mode);
return conv(to_displayable_srgb(color));
}
function clampGamut(mode = "rgb") {
const { gamut } = getMode(mode);
if (!gamut) {
return (color) => prepare_default(color);
}
const destMode = typeof gamut === "string" ? gamut : mode;
const destConv = converter_default(destMode);
const inDestGamut = inGamut(destMode);
return (color) => {
const original = prepare_default(color);
if (!original) {
return void 0;
}
const converted = destConv(original);
if (inDestGamut(converted)) {
return original;
}
const clamped = fixup_rgb(converted);
if (original.mode === clamped.mode) {
return clamped;
}
return converter_default(original.mode)(clamped);
};
}
function clampChroma(color, mode = "lch", rgbGamut = "rgb") {
color = prepare_default(color);
let inDestinationGamut = rgbGamut === "rgb" ? displayable : inGamut(rgbGamut);
let clipToGamut = rgbGamut === "rgb" ? to_displayable_srgb : clampGamut(rgbGamut);
if (color === void 0 || inDestinationGamut(color))
return color;
let conv = converter_default(color.mode);
color = converter_default(mode)(color);
let clamped = { ...color, c: 0 };
if (!inDestinationGamut(clamped)) {
return conv(clipToGamut(clamped));
}
let start = 0;
let end = color.c;
let range = getMode(mode).ranges.c;
let resolution = (range[1] - range[0]) / Math.pow(2, 13);
let _last_good_c;
while (end - start > resolution) {
clamped.c = start + (end - start) * 0.5;
if (inDestinationGamut(clamped)) {
_last_good_c = clamped.c;
start = clamped.c;
} else {
end = clamped.c;
}
}
return conv(
inDestinationGamut(clamped) ? clamped : { ...clamped, c: _last_good_c }
);
}
function toGamut(dest = "rgb", mode = "oklch", delta = differenceEuclidean("oklch"), jnd = 0.02) {
const destConv = converter_default(dest);
if (!getMode(dest).gamut) {
return (color) => destConv(color);
}
const inDestinationGamut = inGamut(dest);
const clipToGamut = clampGamut(dest);
const ucs = converter_default(mode);
const { ranges } = getMode(mode);
const White = destConv("white");
const Black = destConv("black");
return (color) => {
color = prepare_default(color);
if (color === void 0) {
return void 0;
}
const candidate = { ...ucs(color) };
if (candidate.l >= ranges.l[1]) {
const res = { ...White };
if (color.alpha !== void 0) {
res.alpha = color.alpha;
}
return res;
}
if (candidate.l <= ranges.l[0]) {
const res = { ...Black };
if (color.alpha !== void 0) {
res.alpha = color.alpha;
}
return res;
}
if (inDestinationGamut(candidate)) {
return destConv(candidate);
}
let start = 0;
let end = candidate.c;
let epsilon = (ranges.c[1] - ranges.c[0]) / 4e3;
let clipped = clipToGamut(candidate);
while (end - start > epsilon) {
candidate.c = (start + end) * 0.5;
clipped = clipToGamut(candidate);
if (inDestinationGamut(candidate) || delta && jnd > 0 && delta(candidate, clipped) <= jnd) {
start = candidate.c;
} else {
end = candidate.c;
}
}
return destConv(inDestinationGamut(candidate) ? candidate : clipped);
};
}
// src/nearest.js
var nearest = (colors, metric = differenceEuclidean(), accessor = (d) => d) => {
let arr = colors.map((c4, idx) => ({ color: accessor(c4), i: idx }));
return (color, n3 = 1, \u03C4 = Infinity) => {
if (isFinite(n3)) {
n3 = Math.max(1, Math.min(n3, arr.length - 1));
}
arr.forEach((c4) => {
c4.d = metric(color, c4.color);
});
return arr.sort((a, b) => a.d - b.d).slice(0, n3).filter((c4) => c4.d < \u03C4).map((c4) => colors[c4.i]);
};
};
var nearest_default = nearest;
// src/filter.js
var minzero = (v) => Math.max(v, 0);
var clamp2 = (v) => Math.max(Math.min(v, 1), 0);
var lerp2 = (a, b, t) => a === void 0 || b === void 0 ? void 0 : a + t * (b - a);
var matrixSepia = (amount) => {
let a = 1 - clamp2(amount);
return [
0.393 + 0.607 * a,
0.769 - 0.769 * a,
0.189 - 0.189 * a,
0,
0.349 - 0.349 * a,
0.686 + 0.314 * a,
0.168 - 0.168 * a,
0,
0.272 - 0.272 * a,
0.534 - 0.534 * a,
0.131 + 0.869 * a,
0,
0,
0,
0,
1
];
};
var matrixSaturate = (sat) => {
let s = minzero(sat);
return [
0.213 + 0.787 * s,
0.715 - 0.715 * s,
0.072 - 0.072 * s,
0,
0.213 - 0.213 * s,
0.715 + 0.285 * s,
0.072 - 0.072 * s,
0,
0.213 - 0.213 * s,
0.715 - 0.715 * s,
0.072 + 0.928 * s,
0,
0,
0,
0,
1
];
};
var matrixGrayscale = (amount) => {
let a = 1 - clamp2(amount);
return [
0.2126 + 0.7874 * a,
0.7152 - 0.7152 * a,
0.0722 - 0.0722 * a,
0,
0.2126 - 0.2126 * a,
0.7152 + 0.2848 * a,
0.0722 - 0.0722 * a,
0,
0.2126 - 0.2126 * a,
0.7152 - 0.7152 * a,
0.0722 + 0.9278 * a,
0,
0,
0,
0,
1
];
};
var matrixHueRotate = (degrees) => {
let rad = Math.PI * degrees / 180;
let c4 = Math.cos(rad);
let s = Math.sin(rad);
return [
0.213 + c4 * 0.787 - s * 0.213,
0.715 - c4 * 0.715 - s * 0.715,
0.072 - c4 * 0.072 + s * 0.928,
0,
0.213 - c4 * 0.213 + s * 0.143,
0.715 + c4 * 0.285 + s * 0.14,
0.072 - c4 * 0.072 - s * 0.283,
0,
0.213 - c4 * 0.213 - s * 0.787,
0.715 - c4 * 0.715 + s * 0.715,
0.072 + c4 * 0.928 + s * 0.072,
0,
0,
0,
0,
1
];
};
var matrix = (values, mode, preserve_mode = false) => {
let conv = converter_default(mode);
let channels = getMode(mode).channels;
return (color) => {
let c4 = conv(color);
if (!c4) {
return void 0;
}
let res = { mode };
let ch;
let count = channels.length;
for (let i = 0; i < values.length; i++) {
ch = channels[Math.floor(i / count)];
if (c4[ch] === void 0) {
continue;
}
res[ch] = (res[ch] || 0) + values[i] * (c4[channels[i % count]] || 0);
}
if (!preserve_mode) {
return res;
}
let prep = prepare_default(color);
return prep && res.mode !== prep.mode ? converter_default(prep.mode)(res) : res;
};
};
var filterBrightness = (amt = 1, mode = "rgb") => {
let a = minzero(amt);
return mapper(mapTransferLinear(a), mode, true);
};
var filterContrast = (amt = 1, mode = "rgb") => {
let a = minzero(amt);
return mapper(mapTransferLinear(a, (1 - a) / 2), mode, true);
};
var filterSepia = (amt = 1, mode = "rgb") => matrix(matrixSepia(amt), mode, true);
var filterSaturate = (amt = 1, mode = "rgb") => matrix(matrixSaturate(amt), mode, true);
var filterGrayscale = (amt = 1, mode = "rgb") => matrix(matrixGrayscale(amt), mode, true);
var filterInvert = (amt = 1, mode = "rgb") => {
let a = clamp2(amt);
return mapper(
(v, ch) => ch === "alpha" ? v : lerp2(a, 1 - a, v),
mode,
true
);
};
var filterHueRotate = (deg = 0, mode = "rgb") => matrix(matrixHueRotate(deg), mode, true);
// src/deficiency.js
var rgb2 = converter_default("rgb");
var PROT = [
[1, 0, -0, 0, 1, 0, -0, -0, 1],
[
0.856167,
0.182038,
-0.038205,
0.029342,
0.955115,
0.015544,
-288e-5,
-1563e-6,
1.004443
],
[
0.734766,
0.334872,
-0.069637,
0.05184,
0.919198,
0.028963,
-4928e-6,
-4209e-6,
1.009137
],
[
0.630323,
0.465641,
-0.095964,
0.069181,
0.890046,
0.040773,
-6308e-6,
-7724e-6,
1.014032
],
[
0.539009,
0.579343,
-0.118352,
0.082546,
0.866121,
0.051332,
-7136e-6,
-0.011959,
1.019095
],
[
0.458064,
0.679578,
-0.137642,
0.092785,
0.846313,
0.060902,
-7494e-6,
-0.016807,
1.024301
],
[
0.38545,
0.769005,
-0.154455,
0.100526,
0.829802,
0.069673,
-7442e-6,
-0.02219,
1.029632
],
[
0.319627,
0.849633,
-0.169261,
0.106241,
0.815969,
0.07779,
-7025e-6,
-0.028051,
1.035076
],
[
0.259411,
0.923008,
-0.18242,
0.110296,
0.80434,
0.085364,
-6276e-6,
-0.034346,
1.040622
],
[
0.203876,
0.990338,
-0.194214,
0.112975,
0.794542,
0.092483,
-5222e-6,
-0.041043,
1.046265
],
[
0.152286,
1.052583,
-0.204868,
0.114503,
0.786281,
0.099216,
-3882e-6,
-0.048116,
1.051998
]
];
var DEUTER = [
[1, 0, -0, 0, 1, 0, -0, -0, 1],
[
0.866435,
0.177704,
-0.044139,
0.049567,
0.939063,
0.01137,
-3453e-6,
7233e-6,
0.99622
],
[
0.760729,
0.319078,
-0.079807,
0.090568,
0.889315,
0.020117,
-6027e-6,
0.013325,
0.992702
],
[
0.675425,
0.43385,
-0.109275,
0.125303,
0.847755,
0.026942,
-795e-5,
0.018572,
0.989378
],
[
0.605511,
0.52856,
-0.134071,
0.155318,
0.812366,
0.032316,
-9376e-6,
0.023176,
0.9862
],
[
0.547494,
0.607765,
-0.155259,
0.181692,
0.781742,
0.036566,
-0.01041,
0.027275,
0.983136
],
[
0.498864,
0.674741,
-0.173604,
0.205199,
0.754872,
0.039929,
-0.011131,
0.030969,
0.980162
],
[
0.457771,
0.731899,
-0.18967,
0.226409,
0.731012,
0.042579,
-0.011595,
0.034333,
0.977261
],
[
0.422823,
0.781057,
-0.203881,
0.245752,
0.709602,
0.044646,
-0.011843,
0.037423,
0.974421
],
[
0.392952,
0.82361,
-0.216562,
0.263559,
0.69021,
0.046232,
-0.01191,
0.040281,
0.97163
],
[
0.367322,
0.860646,
-0.227968,
0.280085,
0.672501,
0.047413,
-0.01182,
0.04294,
0.968881
]
];
var TRIT = [
[1, 0, -0, 0, 1, 0, -0, -0, 1],
[
0.92667,
0.092514,
-0.019184,
0.021191,
0.964503,
0.014306,
8437e-6,
0.054813,
0.93675
],
[
0.89572,
0.13333,
-0.02905,
0.029997,
0.9454,
0.024603,
0.013027,
0.104707,
0.882266
],
[
0.905871,
0.127791,
-0.033662,
0.026856,
0.941251,
0.031893,
0.01341,
0.148296,
0.838294
],
[
0.948035,
0.08949,
-0.037526,
0.014364,
0.946792,
0.038844,
0.010853,
0.193991,
0.795156
],
[
1.017277,
0.027029,
-0.044306,
-6113e-6,
0.958479,
0.047634,
6379e-6,
0.248708,
0.744913
],
[
1.104996,
-0.046633,
-0.058363,
-0.032137,
0.971635,
0.060503,
1336e-6,
0.317922,
0.680742
],
[
1.193214,
-0.109812,
-0.083402,
-0.058496,
0.97941,
0.079086,
-2346e-6,
0.403492,
0.598854
],
[
1.257728,
-0.139648,
-0.118081,
-0.078003,
0.975409,
0.102594,
-3316e-6,
0.501214,
0.502102
],
[
1.278864,
-0.125333,
-0.153531,
-0.084748,
0.957674,
0.127074,
-989e-6,
0.601151,
0.399838
],
[
1.255528,
-0.076749,
-0.178779,
-0.078411,
0.930809,
0.147602,
4733e-6,
0.691367,
0.3039
]
];
var deficiency = (lut, t) => {
let tt = Math.max(0, Math.min(1, t));
let i = Math.round(tt / 0.1);
let w = Math.round(tt % 0.1);
let arr = lut[i];
if (w > 0 && i < lut.length - 1) {
let arr_2 = lut[i + 1];
arr = arr.map((v, idx) => lerp(arr[idx], arr_2[idx], w));
}
return (color) => {
let c4 = prepare_default(color);
if (c4 === void 0) {
return void 0;
}
let { r: r2, g, b } = rgb2(c4);
let ret = {
mode: "rgb",
r: arr[0] * r2 + arr[1] * g + arr[2] * b,
g: arr[3] * r2 + arr[4] * g + arr[5] * b,
b: arr[6] * r2 + arr[7] * g + arr[8] * b
};
if (c4.alpha !== void 0) {
ret.alpha = c4.alpha;
}
return converter_default(c4.mode)(ret);
};
};
var filterDeficiencyProt = (severity = 1) => deficiency(PROT, severity);
var filterDeficiencyDeuter = (severity = 1) => deficiency(DEUTER, severity);
var filterDeficiencyTrit = (severity = 1) => deficiency(TRIT, severity);
// src/easing/smoothstep.js
var easingSmoothstep = (t) => t * t * (3 - 2 * t);
var easingSmoothstepInverse = (t) => 0.5 - Math.sin(Math.asin(1 - 2 * t) / 3);
// src/easing/smootherstep.js
var smootherstep = (t) => t * t * t * (t * (t * 6 - 15) + 10);
var smootherstep_default = smootherstep;
// src/easing/inOutSine.js
var inOutSine = (t) => (1 - Math.cos(t * Math.PI)) / 2;
var inOutSine_default = inOutSine;
// src/wcag.js
function luminance(color) {
let c4 = converter_default("lrgb")(color);
return 0.2126 * c4.r + 0.7152 * c4.g + 0.0722 * c4.b;
}
function contrast(a, b) {
let L1 = luminance(a);
let L2 = luminance(b);
return (Math.max(L1, L2) + 0.05) / (Math.min(L1, L2) + 0.05);
}
// src/index.js
var a98 = useMode(definition_default2);
var cubehelix = useMode(definition_default3);
var dlab = useMode(definition_default4);
var dlch = useMode(definition_default5);
var hsi = useMode(definition_default6);
var hsl = useMode(definition_default7);
var hsv = useMode(definition_default8);
var hwb = useMode(definition_default9);
var jab = useMode(definition_default10);
var jch = useMode(definition_default11);
var lab = useMode(definition_default12);
var lab65 = useMode(definition_default13);
var lch = useMode(definition_default14);
var lch65 = useMode(definition_default15);
var lchuv = useMode(definition_default16);
var lrgb = useMode(definition_default17);
var luv = useMode(definition_default18);
var okhsl = useMode(modeOkhsl_default);
var okhsv = useMode(modeOkhsv_default);
var oklab = useMode(definition_default19);
var oklch = useMode(definition_default20);
var p3 = useMode(definition_default21);
var prophoto = useMode(definition_default22);
var rec2020 = useMode(definition_default23);
var rgb3 = useMode(definition_default);
var xyb = useMode(definition_default24);
var xyz50 = useMode(definition_default25);
var xyz65 = useMode(definition_default26);
var yiq = useMode(definition_default27);
return __toCommonJS(src_exports);
})();
Reference in New Issue View Git Blame Copy Permalink