812 lines
25 KiB
JavaScript
812 lines
25 KiB
JavaScript
import {
|
|
_defineProperty,
|
|
init_defineProperty
|
|
} from "./chunk-R546NDVX.js";
|
|
import {
|
|
__esm,
|
|
__export
|
|
} from "./chunk-V4OQ3NZ2.js";
|
|
|
|
// node_modules/@ant-design/fast-color/es/FastColor.js
|
|
function splitColorStr(str, parseNum) {
|
|
const match = str.replace(/^[^(]*\((.*)/, "$1").replace(/\).*/, "").match(/\d*\.?\d+%?/g) || [];
|
|
const numList = match.map((item) => parseFloat(item));
|
|
for (let i = 0; i < 3; i += 1) {
|
|
numList[i] = parseNum(numList[i] || 0, match[i] || "", i);
|
|
}
|
|
if (match[3]) {
|
|
numList[3] = match[3].includes("%") ? numList[3] / 100 : numList[3];
|
|
} else {
|
|
numList[3] = 1;
|
|
}
|
|
return numList;
|
|
}
|
|
function limitRange(value, max) {
|
|
const mergedMax = max || 255;
|
|
if (value > mergedMax) {
|
|
return mergedMax;
|
|
}
|
|
if (value < 0) {
|
|
return 0;
|
|
}
|
|
return value;
|
|
}
|
|
var round, parseHSVorHSL, FastColor;
|
|
var init_FastColor = __esm({
|
|
"node_modules/@ant-design/fast-color/es/FastColor.js"() {
|
|
init_defineProperty();
|
|
round = Math.round;
|
|
parseHSVorHSL = (num, _, index) => index === 0 ? num : num / 100;
|
|
FastColor = class _FastColor {
|
|
constructor(input) {
|
|
_defineProperty(this, "isValid", true);
|
|
_defineProperty(this, "r", 0);
|
|
_defineProperty(this, "g", 0);
|
|
_defineProperty(this, "b", 0);
|
|
_defineProperty(this, "a", 1);
|
|
_defineProperty(this, "_h", void 0);
|
|
_defineProperty(this, "_s", void 0);
|
|
_defineProperty(this, "_l", void 0);
|
|
_defineProperty(this, "_v", void 0);
|
|
_defineProperty(this, "_max", void 0);
|
|
_defineProperty(this, "_min", void 0);
|
|
_defineProperty(this, "_brightness", void 0);
|
|
function matchFormat(str) {
|
|
return str[0] in input && str[1] in input && str[2] in input;
|
|
}
|
|
if (!input) {
|
|
} else if (typeof input === "string") {
|
|
let matchPrefix = function(prefix) {
|
|
return trimStr.startsWith(prefix);
|
|
};
|
|
const trimStr = input.trim();
|
|
if (/^#?[A-F\d]{3,8}$/i.test(trimStr)) {
|
|
this.fromHexString(trimStr);
|
|
} else if (matchPrefix("rgb")) {
|
|
this.fromRgbString(trimStr);
|
|
} else if (matchPrefix("hsl")) {
|
|
this.fromHslString(trimStr);
|
|
} else if (matchPrefix("hsv") || matchPrefix("hsb")) {
|
|
this.fromHsvString(trimStr);
|
|
}
|
|
} else if (input instanceof _FastColor) {
|
|
this.r = input.r;
|
|
this.g = input.g;
|
|
this.b = input.b;
|
|
this.a = input.a;
|
|
this._h = input._h;
|
|
this._s = input._s;
|
|
this._l = input._l;
|
|
this._v = input._v;
|
|
} else if (matchFormat("rgb")) {
|
|
this.r = limitRange(input.r);
|
|
this.g = limitRange(input.g);
|
|
this.b = limitRange(input.b);
|
|
this.a = typeof input.a === "number" ? limitRange(input.a, 1) : 1;
|
|
} else if (matchFormat("hsl")) {
|
|
this.fromHsl(input);
|
|
} else if (matchFormat("hsv")) {
|
|
this.fromHsv(input);
|
|
} else {
|
|
throw new Error("@ant-design/fast-color: unsupported input " + JSON.stringify(input));
|
|
}
|
|
}
|
|
// ======================= Setter =======================
|
|
setR(value) {
|
|
return this._sc("r", value);
|
|
}
|
|
setG(value) {
|
|
return this._sc("g", value);
|
|
}
|
|
setB(value) {
|
|
return this._sc("b", value);
|
|
}
|
|
setA(value) {
|
|
return this._sc("a", value, 1);
|
|
}
|
|
setHue(value) {
|
|
const hsv = this.toHsv();
|
|
hsv.h = value;
|
|
return this._c(hsv);
|
|
}
|
|
// ======================= Getter =======================
|
|
/**
|
|
* Returns the perceived luminance of a color, from 0-1.
|
|
* @see http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
|
|
*/
|
|
getLuminance() {
|
|
function adjustGamma(raw) {
|
|
const val = raw / 255;
|
|
return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
|
|
}
|
|
const R = adjustGamma(this.r);
|
|
const G = adjustGamma(this.g);
|
|
const B = adjustGamma(this.b);
|
|
return 0.2126 * R + 0.7152 * G + 0.0722 * B;
|
|
}
|
|
getHue() {
|
|
if (typeof this._h === "undefined") {
|
|
const delta = this.getMax() - this.getMin();
|
|
if (delta === 0) {
|
|
this._h = 0;
|
|
} else {
|
|
this._h = round(60 * (this.r === this.getMax() ? (this.g - this.b) / delta + (this.g < this.b ? 6 : 0) : this.g === this.getMax() ? (this.b - this.r) / delta + 2 : (this.r - this.g) / delta + 4));
|
|
}
|
|
}
|
|
return this._h;
|
|
}
|
|
getSaturation() {
|
|
if (typeof this._s === "undefined") {
|
|
const delta = this.getMax() - this.getMin();
|
|
if (delta === 0) {
|
|
this._s = 0;
|
|
} else {
|
|
this._s = delta / this.getMax();
|
|
}
|
|
}
|
|
return this._s;
|
|
}
|
|
getLightness() {
|
|
if (typeof this._l === "undefined") {
|
|
this._l = (this.getMax() + this.getMin()) / 510;
|
|
}
|
|
return this._l;
|
|
}
|
|
getValue() {
|
|
if (typeof this._v === "undefined") {
|
|
this._v = this.getMax() / 255;
|
|
}
|
|
return this._v;
|
|
}
|
|
/**
|
|
* Returns the perceived brightness of the color, from 0-255.
|
|
* Note: this is not the b of HSB
|
|
* @see http://www.w3.org/TR/AERT#color-contrast
|
|
*/
|
|
getBrightness() {
|
|
if (typeof this._brightness === "undefined") {
|
|
this._brightness = (this.r * 299 + this.g * 587 + this.b * 114) / 1e3;
|
|
}
|
|
return this._brightness;
|
|
}
|
|
// ======================== Func ========================
|
|
darken(amount = 10) {
|
|
const h = this.getHue();
|
|
const s = this.getSaturation();
|
|
let l = this.getLightness() - amount / 100;
|
|
if (l < 0) {
|
|
l = 0;
|
|
}
|
|
return this._c({
|
|
h,
|
|
s,
|
|
l,
|
|
a: this.a
|
|
});
|
|
}
|
|
lighten(amount = 10) {
|
|
const h = this.getHue();
|
|
const s = this.getSaturation();
|
|
let l = this.getLightness() + amount / 100;
|
|
if (l > 1) {
|
|
l = 1;
|
|
}
|
|
return this._c({
|
|
h,
|
|
s,
|
|
l,
|
|
a: this.a
|
|
});
|
|
}
|
|
/**
|
|
* Mix the current color a given amount with another color, from 0 to 100.
|
|
* 0 means no mixing (return current color).
|
|
*/
|
|
mix(input, amount = 50) {
|
|
const color = this._c(input);
|
|
const p = amount / 100;
|
|
const calc = (key) => (color[key] - this[key]) * p + this[key];
|
|
const rgba = {
|
|
r: round(calc("r")),
|
|
g: round(calc("g")),
|
|
b: round(calc("b")),
|
|
a: round(calc("a") * 100) / 100
|
|
};
|
|
return this._c(rgba);
|
|
}
|
|
/**
|
|
* Mix the color with pure white, from 0 to 100.
|
|
* Providing 0 will do nothing, providing 100 will always return white.
|
|
*/
|
|
tint(amount = 10) {
|
|
return this.mix({
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 1
|
|
}, amount);
|
|
}
|
|
/**
|
|
* Mix the color with pure black, from 0 to 100.
|
|
* Providing 0 will do nothing, providing 100 will always return black.
|
|
*/
|
|
shade(amount = 10) {
|
|
return this.mix({
|
|
r: 0,
|
|
g: 0,
|
|
b: 0,
|
|
a: 1
|
|
}, amount);
|
|
}
|
|
onBackground(background) {
|
|
const bg = this._c(background);
|
|
const alpha = this.a + bg.a * (1 - this.a);
|
|
const calc = (key) => {
|
|
return round((this[key] * this.a + bg[key] * bg.a * (1 - this.a)) / alpha);
|
|
};
|
|
return this._c({
|
|
r: calc("r"),
|
|
g: calc("g"),
|
|
b: calc("b"),
|
|
a: alpha
|
|
});
|
|
}
|
|
// ======================= Status =======================
|
|
isDark() {
|
|
return this.getBrightness() < 128;
|
|
}
|
|
isLight() {
|
|
return this.getBrightness() >= 128;
|
|
}
|
|
// ======================== MISC ========================
|
|
equals(other) {
|
|
return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a;
|
|
}
|
|
clone() {
|
|
return this._c(this);
|
|
}
|
|
// ======================= Format =======================
|
|
toHexString() {
|
|
let hex = "#";
|
|
const rHex = (this.r || 0).toString(16);
|
|
hex += rHex.length === 2 ? rHex : "0" + rHex;
|
|
const gHex = (this.g || 0).toString(16);
|
|
hex += gHex.length === 2 ? gHex : "0" + gHex;
|
|
const bHex = (this.b || 0).toString(16);
|
|
hex += bHex.length === 2 ? bHex : "0" + bHex;
|
|
if (typeof this.a === "number" && this.a >= 0 && this.a < 1) {
|
|
const aHex = round(this.a * 255).toString(16);
|
|
hex += aHex.length === 2 ? aHex : "0" + aHex;
|
|
}
|
|
return hex;
|
|
}
|
|
/** CSS support color pattern */
|
|
toHsl() {
|
|
return {
|
|
h: this.getHue(),
|
|
s: this.getSaturation(),
|
|
l: this.getLightness(),
|
|
a: this.a
|
|
};
|
|
}
|
|
/** CSS support color pattern */
|
|
toHslString() {
|
|
const h = this.getHue();
|
|
const s = round(this.getSaturation() * 100);
|
|
const l = round(this.getLightness() * 100);
|
|
return this.a !== 1 ? `hsla(${h},${s}%,${l}%,${this.a})` : `hsl(${h},${s}%,${l}%)`;
|
|
}
|
|
/** Same as toHsb */
|
|
toHsv() {
|
|
return {
|
|
h: this.getHue(),
|
|
s: this.getSaturation(),
|
|
v: this.getValue(),
|
|
a: this.a
|
|
};
|
|
}
|
|
toRgb() {
|
|
return {
|
|
r: this.r,
|
|
g: this.g,
|
|
b: this.b,
|
|
a: this.a
|
|
};
|
|
}
|
|
toRgbString() {
|
|
return this.a !== 1 ? `rgba(${this.r},${this.g},${this.b},${this.a})` : `rgb(${this.r},${this.g},${this.b})`;
|
|
}
|
|
toString() {
|
|
return this.toRgbString();
|
|
}
|
|
// ====================== Privates ======================
|
|
/** Return a new FastColor object with one channel changed */
|
|
_sc(rgb, value, max) {
|
|
const clone = this.clone();
|
|
clone[rgb] = limitRange(value, max);
|
|
return clone;
|
|
}
|
|
_c(input) {
|
|
return new this.constructor(input);
|
|
}
|
|
getMax() {
|
|
if (typeof this._max === "undefined") {
|
|
this._max = Math.max(this.r, this.g, this.b);
|
|
}
|
|
return this._max;
|
|
}
|
|
getMin() {
|
|
if (typeof this._min === "undefined") {
|
|
this._min = Math.min(this.r, this.g, this.b);
|
|
}
|
|
return this._min;
|
|
}
|
|
fromHexString(trimStr) {
|
|
const withoutPrefix = trimStr.replace("#", "");
|
|
function connectNum(index1, index2) {
|
|
return parseInt(withoutPrefix[index1] + withoutPrefix[index2 || index1], 16);
|
|
}
|
|
if (withoutPrefix.length < 6) {
|
|
this.r = connectNum(0);
|
|
this.g = connectNum(1);
|
|
this.b = connectNum(2);
|
|
this.a = withoutPrefix[3] ? connectNum(3) / 255 : 1;
|
|
} else {
|
|
this.r = connectNum(0, 1);
|
|
this.g = connectNum(2, 3);
|
|
this.b = connectNum(4, 5);
|
|
this.a = withoutPrefix[6] ? connectNum(6, 7) / 255 : 1;
|
|
}
|
|
}
|
|
fromHsl({
|
|
h,
|
|
s,
|
|
l,
|
|
a
|
|
}) {
|
|
this._h = h % 360;
|
|
this._s = s;
|
|
this._l = l;
|
|
this.a = typeof a === "number" ? a : 1;
|
|
if (s <= 0) {
|
|
const rgb = round(l * 255);
|
|
this.r = rgb;
|
|
this.g = rgb;
|
|
this.b = rgb;
|
|
}
|
|
let r = 0, g = 0, b = 0;
|
|
const huePrime = h / 60;
|
|
const chroma = (1 - Math.abs(2 * l - 1)) * s;
|
|
const secondComponent = chroma * (1 - Math.abs(huePrime % 2 - 1));
|
|
if (huePrime >= 0 && huePrime < 1) {
|
|
r = chroma;
|
|
g = secondComponent;
|
|
} else if (huePrime >= 1 && huePrime < 2) {
|
|
r = secondComponent;
|
|
g = chroma;
|
|
} else if (huePrime >= 2 && huePrime < 3) {
|
|
g = chroma;
|
|
b = secondComponent;
|
|
} else if (huePrime >= 3 && huePrime < 4) {
|
|
g = secondComponent;
|
|
b = chroma;
|
|
} else if (huePrime >= 4 && huePrime < 5) {
|
|
r = secondComponent;
|
|
b = chroma;
|
|
} else if (huePrime >= 5 && huePrime < 6) {
|
|
r = chroma;
|
|
b = secondComponent;
|
|
}
|
|
const lightnessModification = l - chroma / 2;
|
|
this.r = round((r + lightnessModification) * 255);
|
|
this.g = round((g + lightnessModification) * 255);
|
|
this.b = round((b + lightnessModification) * 255);
|
|
}
|
|
fromHsv({
|
|
h,
|
|
s,
|
|
v,
|
|
a
|
|
}) {
|
|
this._h = h % 360;
|
|
this._s = s;
|
|
this._v = v;
|
|
this.a = typeof a === "number" ? a : 1;
|
|
const vv = round(v * 255);
|
|
this.r = vv;
|
|
this.g = vv;
|
|
this.b = vv;
|
|
if (s <= 0) {
|
|
return;
|
|
}
|
|
const hh = h / 60;
|
|
const i = Math.floor(hh);
|
|
const ff = hh - i;
|
|
const p = round(v * (1 - s) * 255);
|
|
const q = round(v * (1 - s * ff) * 255);
|
|
const t = round(v * (1 - s * (1 - ff)) * 255);
|
|
switch (i) {
|
|
case 0:
|
|
this.g = t;
|
|
this.b = p;
|
|
break;
|
|
case 1:
|
|
this.r = q;
|
|
this.b = p;
|
|
break;
|
|
case 2:
|
|
this.r = p;
|
|
this.b = t;
|
|
break;
|
|
case 3:
|
|
this.r = p;
|
|
this.g = q;
|
|
break;
|
|
case 4:
|
|
this.r = t;
|
|
this.g = p;
|
|
break;
|
|
case 5:
|
|
default:
|
|
this.g = p;
|
|
this.b = q;
|
|
break;
|
|
}
|
|
}
|
|
fromHsvString(trimStr) {
|
|
const cells = splitColorStr(trimStr, parseHSVorHSL);
|
|
this.fromHsv({
|
|
h: cells[0],
|
|
s: cells[1],
|
|
v: cells[2],
|
|
a: cells[3]
|
|
});
|
|
}
|
|
fromHslString(trimStr) {
|
|
const cells = splitColorStr(trimStr, parseHSVorHSL);
|
|
this.fromHsl({
|
|
h: cells[0],
|
|
s: cells[1],
|
|
l: cells[2],
|
|
a: cells[3]
|
|
});
|
|
}
|
|
fromRgbString(trimStr) {
|
|
const cells = splitColorStr(trimStr, (num, txt) => (
|
|
// Convert percentage to number. e.g. 50% -> 128
|
|
txt.includes("%") ? round(num / 100 * 255) : num
|
|
));
|
|
this.r = cells[0];
|
|
this.g = cells[1];
|
|
this.b = cells[2];
|
|
this.a = cells[3];
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@ant-design/fast-color/es/types.js
|
|
var init_types = __esm({
|
|
"node_modules/@ant-design/fast-color/es/types.js"() {
|
|
}
|
|
});
|
|
|
|
// node_modules/@ant-design/fast-color/es/index.js
|
|
var init_es = __esm({
|
|
"node_modules/@ant-design/fast-color/es/index.js"() {
|
|
init_FastColor();
|
|
init_types();
|
|
}
|
|
});
|
|
|
|
// node_modules/@ant-design/colors/es/generate.js
|
|
function getHue(hsv, i, light) {
|
|
var hue;
|
|
if (Math.round(hsv.h) >= 60 && Math.round(hsv.h) <= 240) {
|
|
hue = light ? Math.round(hsv.h) - hueStep * i : Math.round(hsv.h) + hueStep * i;
|
|
} else {
|
|
hue = light ? Math.round(hsv.h) + hueStep * i : Math.round(hsv.h) - hueStep * i;
|
|
}
|
|
if (hue < 0) {
|
|
hue += 360;
|
|
} else if (hue >= 360) {
|
|
hue -= 360;
|
|
}
|
|
return hue;
|
|
}
|
|
function getSaturation(hsv, i, light) {
|
|
if (hsv.h === 0 && hsv.s === 0) {
|
|
return hsv.s;
|
|
}
|
|
var saturation;
|
|
if (light) {
|
|
saturation = hsv.s - saturationStep * i;
|
|
} else if (i === darkColorCount) {
|
|
saturation = hsv.s + saturationStep;
|
|
} else {
|
|
saturation = hsv.s + saturationStep2 * i;
|
|
}
|
|
if (saturation > 1) {
|
|
saturation = 1;
|
|
}
|
|
if (light && i === lightColorCount && saturation > 0.1) {
|
|
saturation = 0.1;
|
|
}
|
|
if (saturation < 0.06) {
|
|
saturation = 0.06;
|
|
}
|
|
return Math.round(saturation * 100) / 100;
|
|
}
|
|
function getValue(hsv, i, light) {
|
|
var value;
|
|
if (light) {
|
|
value = hsv.v + brightnessStep1 * i;
|
|
} else {
|
|
value = hsv.v - brightnessStep2 * i;
|
|
}
|
|
value = Math.max(0, Math.min(1, value));
|
|
return Math.round(value * 100) / 100;
|
|
}
|
|
function generate(color) {
|
|
var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
|
|
var patterns = [];
|
|
var pColor = new FastColor(color);
|
|
var hsv = pColor.toHsv();
|
|
for (var i = lightColorCount; i > 0; i -= 1) {
|
|
var c = new FastColor({
|
|
h: getHue(hsv, i, true),
|
|
s: getSaturation(hsv, i, true),
|
|
v: getValue(hsv, i, true)
|
|
});
|
|
patterns.push(c);
|
|
}
|
|
patterns.push(pColor);
|
|
for (var _i = 1; _i <= darkColorCount; _i += 1) {
|
|
var _c = new FastColor({
|
|
h: getHue(hsv, _i),
|
|
s: getSaturation(hsv, _i),
|
|
v: getValue(hsv, _i)
|
|
});
|
|
patterns.push(_c);
|
|
}
|
|
if (opts.theme === "dark") {
|
|
return darkColorMap.map(function(_ref) {
|
|
var index = _ref.index, amount = _ref.amount;
|
|
return new FastColor(opts.backgroundColor || "#141414").mix(patterns[index], amount).toHexString();
|
|
});
|
|
}
|
|
return patterns.map(function(c2) {
|
|
return c2.toHexString();
|
|
});
|
|
}
|
|
var hueStep, saturationStep, saturationStep2, brightnessStep1, brightnessStep2, lightColorCount, darkColorCount, darkColorMap;
|
|
var init_generate = __esm({
|
|
"node_modules/@ant-design/colors/es/generate.js"() {
|
|
init_es();
|
|
hueStep = 2;
|
|
saturationStep = 0.16;
|
|
saturationStep2 = 0.05;
|
|
brightnessStep1 = 0.05;
|
|
brightnessStep2 = 0.15;
|
|
lightColorCount = 5;
|
|
darkColorCount = 4;
|
|
darkColorMap = [{
|
|
index: 7,
|
|
amount: 15
|
|
}, {
|
|
index: 6,
|
|
amount: 25
|
|
}, {
|
|
index: 5,
|
|
amount: 30
|
|
}, {
|
|
index: 5,
|
|
amount: 45
|
|
}, {
|
|
index: 5,
|
|
amount: 65
|
|
}, {
|
|
index: 5,
|
|
amount: 85
|
|
}, {
|
|
index: 4,
|
|
amount: 90
|
|
}, {
|
|
index: 3,
|
|
amount: 95
|
|
}, {
|
|
index: 2,
|
|
amount: 97
|
|
}, {
|
|
index: 1,
|
|
amount: 98
|
|
}];
|
|
}
|
|
});
|
|
|
|
// node_modules/@ant-design/colors/es/presets.js
|
|
var presetPrimaryColors, red, volcano, orange, gold, yellow, lime, green, cyan, blue, geekblue, purple, magenta, grey, gray, presetPalettes, redDark, volcanoDark, orangeDark, goldDark, yellowDark, limeDark, greenDark, cyanDark, blueDark, geekblueDark, purpleDark, magentaDark, greyDark, presetDarkPalettes;
|
|
var init_presets = __esm({
|
|
"node_modules/@ant-design/colors/es/presets.js"() {
|
|
presetPrimaryColors = {
|
|
"red": "#F5222D",
|
|
"volcano": "#FA541C",
|
|
"orange": "#FA8C16",
|
|
"gold": "#FAAD14",
|
|
"yellow": "#FADB14",
|
|
"lime": "#A0D911",
|
|
"green": "#52C41A",
|
|
"cyan": "#13C2C2",
|
|
"blue": "#1677FF",
|
|
"geekblue": "#2F54EB",
|
|
"purple": "#722ED1",
|
|
"magenta": "#EB2F96",
|
|
"grey": "#666666"
|
|
};
|
|
red = ["#fff1f0", "#ffccc7", "#ffa39e", "#ff7875", "#ff4d4f", "#f5222d", "#cf1322", "#a8071a", "#820014", "#5c0011"];
|
|
red.primary = red[5];
|
|
volcano = ["#fff2e8", "#ffd8bf", "#ffbb96", "#ff9c6e", "#ff7a45", "#fa541c", "#d4380d", "#ad2102", "#871400", "#610b00"];
|
|
volcano.primary = volcano[5];
|
|
orange = ["#fff7e6", "#ffe7ba", "#ffd591", "#ffc069", "#ffa940", "#fa8c16", "#d46b08", "#ad4e00", "#873800", "#612500"];
|
|
orange.primary = orange[5];
|
|
gold = ["#fffbe6", "#fff1b8", "#ffe58f", "#ffd666", "#ffc53d", "#faad14", "#d48806", "#ad6800", "#874d00", "#613400"];
|
|
gold.primary = gold[5];
|
|
yellow = ["#feffe6", "#ffffb8", "#fffb8f", "#fff566", "#ffec3d", "#fadb14", "#d4b106", "#ad8b00", "#876800", "#614700"];
|
|
yellow.primary = yellow[5];
|
|
lime = ["#fcffe6", "#f4ffb8", "#eaff8f", "#d3f261", "#bae637", "#a0d911", "#7cb305", "#5b8c00", "#3f6600", "#254000"];
|
|
lime.primary = lime[5];
|
|
green = ["#f6ffed", "#d9f7be", "#b7eb8f", "#95de64", "#73d13d", "#52c41a", "#389e0d", "#237804", "#135200", "#092b00"];
|
|
green.primary = green[5];
|
|
cyan = ["#e6fffb", "#b5f5ec", "#87e8de", "#5cdbd3", "#36cfc9", "#13c2c2", "#08979c", "#006d75", "#00474f", "#002329"];
|
|
cyan.primary = cyan[5];
|
|
blue = ["#e6f4ff", "#bae0ff", "#91caff", "#69b1ff", "#4096ff", "#1677ff", "#0958d9", "#003eb3", "#002c8c", "#001d66"];
|
|
blue.primary = blue[5];
|
|
geekblue = ["#f0f5ff", "#d6e4ff", "#adc6ff", "#85a5ff", "#597ef7", "#2f54eb", "#1d39c4", "#10239e", "#061178", "#030852"];
|
|
geekblue.primary = geekblue[5];
|
|
purple = ["#f9f0ff", "#efdbff", "#d3adf7", "#b37feb", "#9254de", "#722ed1", "#531dab", "#391085", "#22075e", "#120338"];
|
|
purple.primary = purple[5];
|
|
magenta = ["#fff0f6", "#ffd6e7", "#ffadd2", "#ff85c0", "#f759ab", "#eb2f96", "#c41d7f", "#9e1068", "#780650", "#520339"];
|
|
magenta.primary = magenta[5];
|
|
grey = ["#a6a6a6", "#999999", "#8c8c8c", "#808080", "#737373", "#666666", "#404040", "#1a1a1a", "#000000", "#000000"];
|
|
grey.primary = grey[5];
|
|
gray = grey;
|
|
presetPalettes = {
|
|
red,
|
|
volcano,
|
|
orange,
|
|
gold,
|
|
yellow,
|
|
lime,
|
|
green,
|
|
cyan,
|
|
blue,
|
|
geekblue,
|
|
purple,
|
|
magenta,
|
|
grey
|
|
};
|
|
redDark = ["#2a1215", "#431418", "#58181c", "#791a1f", "#a61d24", "#d32029", "#e84749", "#f37370", "#f89f9a", "#fac8c3"];
|
|
redDark.primary = redDark[5];
|
|
volcanoDark = ["#2b1611", "#441d12", "#592716", "#7c3118", "#aa3e19", "#d84a1b", "#e87040", "#f3956a", "#f8b692", "#fad4bc"];
|
|
volcanoDark.primary = volcanoDark[5];
|
|
orangeDark = ["#2b1d11", "#442a11", "#593815", "#7c4a15", "#aa6215", "#d87a16", "#e89a3c", "#f3b765", "#f8cf8d", "#fae3b7"];
|
|
orangeDark.primary = orangeDark[5];
|
|
goldDark = ["#2b2111", "#443111", "#594214", "#7c5914", "#aa7714", "#d89614", "#e8b339", "#f3cc62", "#f8df8b", "#faedb5"];
|
|
goldDark.primary = goldDark[5];
|
|
yellowDark = ["#2b2611", "#443b11", "#595014", "#7c6e14", "#aa9514", "#d8bd14", "#e8d639", "#f3ea62", "#f8f48b", "#fafab5"];
|
|
yellowDark.primary = yellowDark[5];
|
|
limeDark = ["#1f2611", "#2e3c10", "#3e4f13", "#536d13", "#6f9412", "#8bbb11", "#a9d134", "#c9e75d", "#e4f88b", "#f0fab5"];
|
|
limeDark.primary = limeDark[5];
|
|
greenDark = ["#162312", "#1d3712", "#274916", "#306317", "#3c8618", "#49aa19", "#6abe39", "#8fd460", "#b2e58b", "#d5f2bb"];
|
|
greenDark.primary = greenDark[5];
|
|
cyanDark = ["#112123", "#113536", "#144848", "#146262", "#138585", "#13a8a8", "#33bcb7", "#58d1c9", "#84e2d8", "#b2f1e8"];
|
|
cyanDark.primary = cyanDark[5];
|
|
blueDark = ["#111a2c", "#112545", "#15325b", "#15417e", "#1554ad", "#1668dc", "#3c89e8", "#65a9f3", "#8dc5f8", "#b7dcfa"];
|
|
blueDark.primary = blueDark[5];
|
|
geekblueDark = ["#131629", "#161d40", "#1c2755", "#203175", "#263ea0", "#2b4acb", "#5273e0", "#7f9ef3", "#a8c1f8", "#d2e0fa"];
|
|
geekblueDark.primary = geekblueDark[5];
|
|
purpleDark = ["#1a1325", "#24163a", "#301c4d", "#3e2069", "#51258f", "#642ab5", "#854eca", "#ab7ae0", "#cda8f0", "#ebd7fa"];
|
|
purpleDark.primary = purpleDark[5];
|
|
magentaDark = ["#291321", "#40162f", "#551c3b", "#75204f", "#a02669", "#cb2b83", "#e0529c", "#f37fb7", "#f8a8cc", "#fad2e3"];
|
|
magentaDark.primary = magentaDark[5];
|
|
greyDark = ["#151515", "#1f1f1f", "#2d2d2d", "#393939", "#494949", "#5a5a5a", "#6a6a6a", "#7b7b7b", "#888888", "#969696"];
|
|
greyDark.primary = greyDark[5];
|
|
presetDarkPalettes = {
|
|
red: redDark,
|
|
volcano: volcanoDark,
|
|
orange: orangeDark,
|
|
gold: goldDark,
|
|
yellow: yellowDark,
|
|
lime: limeDark,
|
|
green: greenDark,
|
|
cyan: cyanDark,
|
|
blue: blueDark,
|
|
geekblue: geekblueDark,
|
|
purple: purpleDark,
|
|
magenta: magentaDark,
|
|
grey: greyDark
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@ant-design/colors/es/index.js
|
|
var es_exports = {};
|
|
__export(es_exports, {
|
|
blue: () => blue,
|
|
blueDark: () => blueDark,
|
|
cyan: () => cyan,
|
|
cyanDark: () => cyanDark,
|
|
geekblue: () => geekblue,
|
|
geekblueDark: () => geekblueDark,
|
|
generate: () => generate,
|
|
gold: () => gold,
|
|
goldDark: () => goldDark,
|
|
gray: () => gray,
|
|
green: () => green,
|
|
greenDark: () => greenDark,
|
|
grey: () => grey,
|
|
greyDark: () => greyDark,
|
|
lime: () => lime,
|
|
limeDark: () => limeDark,
|
|
magenta: () => magenta,
|
|
magentaDark: () => magentaDark,
|
|
orange: () => orange,
|
|
orangeDark: () => orangeDark,
|
|
presetDarkPalettes: () => presetDarkPalettes,
|
|
presetPalettes: () => presetPalettes,
|
|
presetPrimaryColors: () => presetPrimaryColors,
|
|
purple: () => purple,
|
|
purpleDark: () => purpleDark,
|
|
red: () => red,
|
|
redDark: () => redDark,
|
|
volcano: () => volcano,
|
|
volcanoDark: () => volcanoDark,
|
|
yellow: () => yellow,
|
|
yellowDark: () => yellowDark
|
|
});
|
|
var init_es2 = __esm({
|
|
"node_modules/@ant-design/colors/es/index.js"() {
|
|
init_generate();
|
|
init_presets();
|
|
}
|
|
});
|
|
|
|
export {
|
|
FastColor,
|
|
init_es,
|
|
generate,
|
|
presetPrimaryColors,
|
|
red,
|
|
volcano,
|
|
orange,
|
|
gold,
|
|
yellow,
|
|
lime,
|
|
green,
|
|
cyan,
|
|
blue,
|
|
geekblue,
|
|
purple,
|
|
magenta,
|
|
grey,
|
|
gray,
|
|
presetPalettes,
|
|
redDark,
|
|
volcanoDark,
|
|
orangeDark,
|
|
goldDark,
|
|
yellowDark,
|
|
limeDark,
|
|
greenDark,
|
|
cyanDark,
|
|
blueDark,
|
|
geekblueDark,
|
|
purpleDark,
|
|
magentaDark,
|
|
greyDark,
|
|
presetDarkPalettes,
|
|
es_exports,
|
|
init_es2
|
|
};
|
|
//# sourceMappingURL=chunk-5T3YOWZX.js.map
|