3722 lines
151 KiB
JavaScript
3722 lines
151 KiB
JavaScript
import { n as __toESM, t as __commonJSMin } from "./chunk-CO3PsZeE.js";
|
|
import { t as require_react } from "./react.js";
|
|
//#region node_modules/@ant-design/icons/es/components/Context.js
|
|
var import_react = /* @__PURE__ */ __toESM(require_react());
|
|
var IconContext = /* @__PURE__ */ (0, import_react.createContext)({});
|
|
//#endregion
|
|
//#region node_modules/clsx/dist/clsx.mjs
|
|
function r(e) {
|
|
var t, f, n = "";
|
|
if ("string" == typeof e || "number" == typeof e) n += e;
|
|
else if ("object" == typeof e) if (Array.isArray(e)) {
|
|
var o = e.length;
|
|
for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
|
|
} else for (f in e) e[f] && (n && (n += " "), n += f);
|
|
return n;
|
|
}
|
|
function clsx() {
|
|
for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
|
|
return n;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@ant-design/fast-color/es/presetColors.js
|
|
var presetColors_default = {
|
|
aliceblue: "9ehhb",
|
|
antiquewhite: "9sgk7",
|
|
aqua: "1ekf",
|
|
aquamarine: "4zsno",
|
|
azure: "9eiv3",
|
|
beige: "9lhp8",
|
|
bisque: "9zg04",
|
|
black: "0",
|
|
blanchedalmond: "9zhe5",
|
|
blue: "73",
|
|
blueviolet: "5e31e",
|
|
brown: "6g016",
|
|
burlywood: "8ouiv",
|
|
cadetblue: "3qba8",
|
|
chartreuse: "4zshs",
|
|
chocolate: "87k0u",
|
|
coral: "9yvyo",
|
|
cornflowerblue: "3xael",
|
|
cornsilk: "9zjz0",
|
|
crimson: "8l4xo",
|
|
cyan: "1ekf",
|
|
darkblue: "3v",
|
|
darkcyan: "rkb",
|
|
darkgoldenrod: "776yz",
|
|
darkgray: "6mbhl",
|
|
darkgreen: "jr4",
|
|
darkgrey: "6mbhl",
|
|
darkkhaki: "7ehkb",
|
|
darkmagenta: "5f91n",
|
|
darkolivegreen: "3bzfz",
|
|
darkorange: "9yygw",
|
|
darkorchid: "5z6x8",
|
|
darkred: "5f8xs",
|
|
darksalmon: "9441m",
|
|
darkseagreen: "5lwgf",
|
|
darkslateblue: "2th1n",
|
|
darkslategray: "1ugcv",
|
|
darkslategrey: "1ugcv",
|
|
darkturquoise: "14up",
|
|
darkviolet: "5rw7n",
|
|
deeppink: "9yavn",
|
|
deepskyblue: "11xb",
|
|
dimgray: "442g9",
|
|
dimgrey: "442g9",
|
|
dodgerblue: "16xof",
|
|
firebrick: "6y7tu",
|
|
floralwhite: "9zkds",
|
|
forestgreen: "1cisi",
|
|
fuchsia: "9y70f",
|
|
gainsboro: "8m8kc",
|
|
ghostwhite: "9pq0v",
|
|
goldenrod: "8j4f4",
|
|
gold: "9zda8",
|
|
gray: "50i2o",
|
|
green: "pa8",
|
|
greenyellow: "6senj",
|
|
grey: "50i2o",
|
|
honeydew: "9eiuo",
|
|
hotpink: "9yrp0",
|
|
indianred: "80gnw",
|
|
indigo: "2xcoy",
|
|
ivory: "9zldc",
|
|
khaki: "9edu4",
|
|
lavenderblush: "9ziet",
|
|
lavender: "90c8q",
|
|
lawngreen: "4vk74",
|
|
lemonchiffon: "9zkct",
|
|
lightblue: "6s73a",
|
|
lightcoral: "9dtog",
|
|
lightcyan: "8s1rz",
|
|
lightgoldenrodyellow: "9sjiq",
|
|
lightgray: "89jo3",
|
|
lightgreen: "5nkwg",
|
|
lightgrey: "89jo3",
|
|
lightpink: "9z6wx",
|
|
lightsalmon: "9z2ii",
|
|
lightseagreen: "19xgq",
|
|
lightskyblue: "5arju",
|
|
lightslategray: "4nwk9",
|
|
lightslategrey: "4nwk9",
|
|
lightsteelblue: "6wau6",
|
|
lightyellow: "9zlcw",
|
|
lime: "1edc",
|
|
limegreen: "1zcxe",
|
|
linen: "9shk6",
|
|
magenta: "9y70f",
|
|
maroon: "4zsow",
|
|
mediumaquamarine: "40eju",
|
|
mediumblue: "5p",
|
|
mediumorchid: "79qkz",
|
|
mediumpurple: "5r3rv",
|
|
mediumseagreen: "2d9ip",
|
|
mediumslateblue: "4tcku",
|
|
mediumspringgreen: "1di2",
|
|
mediumturquoise: "2uabw",
|
|
mediumvioletred: "7rn9h",
|
|
midnightblue: "z980",
|
|
mintcream: "9ljp6",
|
|
mistyrose: "9zg0x",
|
|
moccasin: "9zfzp",
|
|
navajowhite: "9zest",
|
|
navy: "3k",
|
|
oldlace: "9wq92",
|
|
olive: "50hz4",
|
|
olivedrab: "472ub",
|
|
orange: "9z3eo",
|
|
orangered: "9ykg0",
|
|
orchid: "8iu3a",
|
|
palegoldenrod: "9bl4a",
|
|
palegreen: "5yw0o",
|
|
paleturquoise: "6v4ku",
|
|
palevioletred: "8k8lv",
|
|
papayawhip: "9zi6t",
|
|
peachpuff: "9ze0p",
|
|
peru: "80oqn",
|
|
pink: "9z8wb",
|
|
plum: "8nba5",
|
|
powderblue: "6wgdi",
|
|
purple: "4zssg",
|
|
rebeccapurple: "3zk49",
|
|
red: "9y6tc",
|
|
rosybrown: "7cv4f",
|
|
royalblue: "2jvtt",
|
|
saddlebrown: "5fmkz",
|
|
salmon: "9rvci",
|
|
sandybrown: "9jn1c",
|
|
seagreen: "1tdnb",
|
|
seashell: "9zje6",
|
|
sienna: "6973h",
|
|
silver: "7ir40",
|
|
skyblue: "5arjf",
|
|
slateblue: "45e4t",
|
|
slategray: "4e100",
|
|
slategrey: "4e100",
|
|
snow: "9zke2",
|
|
springgreen: "1egv",
|
|
steelblue: "2r1kk",
|
|
tan: "87yx8",
|
|
teal: "pds",
|
|
thistle: "8ggk8",
|
|
tomato: "9yqfb",
|
|
turquoise: "2j4r4",
|
|
violet: "9b10u",
|
|
wheat: "9ld4j",
|
|
white: "9zldr",
|
|
whitesmoke: "9lhpx",
|
|
yellow: "9zl6o",
|
|
yellowgreen: "61fzm"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/fast-color/es/FastColor.js
|
|
var round = Math.round;
|
|
/**
|
|
* Support format, alpha unit will check the % mark:
|
|
* - rgba(102, 204, 255, .5) -> [102, 204, 255, 0.5]
|
|
* - rgb(102 204 255 / .5) -> [102, 204, 255, 0.5]
|
|
* - rgb(100%, 50%, 0% / 50%) -> [255, 128, 0, 0.5]
|
|
* - hsl(270, 60, 40, .5) -> [270, 60, 40, 0.5]
|
|
* - hsl(270deg 60% 40% / 50%) -> [270, 60, 40, 0.5]
|
|
*
|
|
* When `base` is provided, the percentage value will be divided by `base`.
|
|
*/
|
|
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;
|
|
}
|
|
var parseHSVorHSL = (num, _, index) => index === 0 ? num : num / 100;
|
|
/** round and limit number to integer between 0-255 */
|
|
function limitRange(value, max) {
|
|
const mergedMax = max || 255;
|
|
if (value > mergedMax) return mergedMax;
|
|
if (value < 0) return 0;
|
|
return value;
|
|
}
|
|
var FastColor = class FastColor {
|
|
/**
|
|
* All FastColor objects are valid. So isValid is always true. This property is kept to be compatible with TinyColor.
|
|
*/
|
|
isValid = true;
|
|
/**
|
|
* Red, R in RGB
|
|
*/
|
|
r = 0;
|
|
/**
|
|
* Green, G in RGB
|
|
*/
|
|
g = 0;
|
|
/**
|
|
* Blue, B in RGB
|
|
*/
|
|
b = 0;
|
|
/**
|
|
* Alpha/Opacity, A in RGBA/HSLA
|
|
*/
|
|
a = 1;
|
|
_h;
|
|
_hsl_s;
|
|
_hsv_s;
|
|
_l;
|
|
_v;
|
|
_max;
|
|
_min;
|
|
_brightness;
|
|
constructor(input) {
|
|
/**
|
|
* Always check 3 char in the object to determine the format.
|
|
* We not use function in check to save bundle size.
|
|
* e.g. 'rgb' -> { r: 0, g: 0, b: 0 }.
|
|
*/
|
|
function matchFormat(str) {
|
|
return str[0] in input && str[1] in input && str[2] in input;
|
|
}
|
|
if (!input) {} else if (typeof input === "string") {
|
|
const trimStr = input.trim();
|
|
function matchPrefix(prefix) {
|
|
return trimStr.startsWith(prefix);
|
|
}
|
|
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 {
|
|
const presetColor = presetColors_default[trimStr.toLowerCase()];
|
|
if (presetColor) this.fromHexString(parseInt(presetColor, 36).toString(16).padStart(6, "0"));
|
|
}
|
|
} 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._hsl_s = input._hsl_s;
|
|
this._hsv_s = input._hsv_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));
|
|
}
|
|
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);
|
|
}
|
|
/**
|
|
* 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 <= .03928 ? val / 12.92 : Math.pow((val + .055) / 1.055, 2.4);
|
|
}
|
|
const R = adjustGamma(this.r);
|
|
const G = adjustGamma(this.g);
|
|
const B = adjustGamma(this.b);
|
|
return .2126 * R + .7152 * G + .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;
|
|
}
|
|
/**
|
|
* @deprecated should use getHSVSaturation or getHSLSaturation instead
|
|
*/
|
|
getSaturation() {
|
|
return this.getHSVSaturation();
|
|
}
|
|
getHSVSaturation() {
|
|
if (typeof this._hsv_s === "undefined") {
|
|
const delta = this.getMax() - this.getMin();
|
|
if (delta === 0) this._hsv_s = 0;
|
|
else this._hsv_s = delta / this.getMax();
|
|
}
|
|
return this._hsv_s;
|
|
}
|
|
getHSLSaturation() {
|
|
if (typeof this._hsl_s === "undefined") {
|
|
const delta = this.getMax() - this.getMin();
|
|
if (delta === 0) this._hsl_s = 0;
|
|
else {
|
|
const l = this.getLightness();
|
|
this._hsl_s = delta / 255 / (1 - Math.abs(2 * l - 1));
|
|
}
|
|
}
|
|
return this._hsl_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;
|
|
}
|
|
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
|
|
});
|
|
}
|
|
isDark() {
|
|
return this.getBrightness() < 128;
|
|
}
|
|
isLight() {
|
|
return this.getBrightness() >= 128;
|
|
}
|
|
equals(other) {
|
|
return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a;
|
|
}
|
|
clone() {
|
|
return this._c(this);
|
|
}
|
|
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.getHSLSaturation(),
|
|
l: this.getLightness(),
|
|
a: this.a
|
|
};
|
|
}
|
|
/** CSS support color pattern */
|
|
toHslString() {
|
|
const h = this.getHue();
|
|
const s = round(this.getHSLSaturation() * 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.getHSVSaturation(),
|
|
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();
|
|
}
|
|
/** 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: _h, s, l, a }) {
|
|
const h = (_h % 360 + 360) % 360;
|
|
this._h = h;
|
|
this._hsl_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;
|
|
return;
|
|
}
|
|
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: _h, s, v, a }) {
|
|
const h = (_h % 360 + 360) % 360;
|
|
this._h = h;
|
|
this._hsv_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;
|
|
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) => txt.includes("%") ? round(num / 100 * 255) : num);
|
|
this.r = cells[0];
|
|
this.g = cells[1];
|
|
this.b = cells[2];
|
|
this.a = cells[3];
|
|
}
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/colors/es/generate.js
|
|
var hueStep = 2;
|
|
var saturationStep = .16;
|
|
var saturationStep2 = .05;
|
|
var brightnessStep1 = .05;
|
|
var brightnessStep2 = .15;
|
|
var lightColorCount = 5;
|
|
var darkColorCount = 4;
|
|
var 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
|
|
}
|
|
];
|
|
function getHue(hsv, i, light) {
|
|
let 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;
|
|
let 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 > .1) saturation = .1;
|
|
if (saturation < .06) saturation = .06;
|
|
return Math.round(saturation * 100) / 100;
|
|
}
|
|
function getValue(hsv, i, light) {
|
|
let 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$1(color, opts = {}) {
|
|
const patterns = [];
|
|
const pColor = new FastColor(color);
|
|
const hsv = pColor.toHsv();
|
|
for (let i = lightColorCount; i > 0; i -= 1) {
|
|
const 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 (let i = 1; i <= darkColorCount; i += 1) {
|
|
const 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(({ index, amount }) => new FastColor(opts.backgroundColor || "#141414").mix(patterns[index], amount).toHexString());
|
|
return patterns.map((c) => c.toHexString());
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@ant-design/colors/es/presets.js
|
|
var 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"
|
|
};
|
|
var red = [
|
|
"#fff1f0",
|
|
"#ffccc7",
|
|
"#ffa39e",
|
|
"#ff7875",
|
|
"#ff4d4f",
|
|
"#f5222d",
|
|
"#cf1322",
|
|
"#a8071a",
|
|
"#820014",
|
|
"#5c0011"
|
|
];
|
|
red.primary = red[5];
|
|
var volcano = [
|
|
"#fff2e8",
|
|
"#ffd8bf",
|
|
"#ffbb96",
|
|
"#ff9c6e",
|
|
"#ff7a45",
|
|
"#fa541c",
|
|
"#d4380d",
|
|
"#ad2102",
|
|
"#871400",
|
|
"#610b00"
|
|
];
|
|
volcano.primary = volcano[5];
|
|
var orange = [
|
|
"#fff7e6",
|
|
"#ffe7ba",
|
|
"#ffd591",
|
|
"#ffc069",
|
|
"#ffa940",
|
|
"#fa8c16",
|
|
"#d46b08",
|
|
"#ad4e00",
|
|
"#873800",
|
|
"#612500"
|
|
];
|
|
orange.primary = orange[5];
|
|
var gold = [
|
|
"#fffbe6",
|
|
"#fff1b8",
|
|
"#ffe58f",
|
|
"#ffd666",
|
|
"#ffc53d",
|
|
"#faad14",
|
|
"#d48806",
|
|
"#ad6800",
|
|
"#874d00",
|
|
"#613400"
|
|
];
|
|
gold.primary = gold[5];
|
|
var yellow = [
|
|
"#feffe6",
|
|
"#ffffb8",
|
|
"#fffb8f",
|
|
"#fff566",
|
|
"#ffec3d",
|
|
"#fadb14",
|
|
"#d4b106",
|
|
"#ad8b00",
|
|
"#876800",
|
|
"#614700"
|
|
];
|
|
yellow.primary = yellow[5];
|
|
var lime = [
|
|
"#fcffe6",
|
|
"#f4ffb8",
|
|
"#eaff8f",
|
|
"#d3f261",
|
|
"#bae637",
|
|
"#a0d911",
|
|
"#7cb305",
|
|
"#5b8c00",
|
|
"#3f6600",
|
|
"#254000"
|
|
];
|
|
lime.primary = lime[5];
|
|
var green = [
|
|
"#f6ffed",
|
|
"#d9f7be",
|
|
"#b7eb8f",
|
|
"#95de64",
|
|
"#73d13d",
|
|
"#52c41a",
|
|
"#389e0d",
|
|
"#237804",
|
|
"#135200",
|
|
"#092b00"
|
|
];
|
|
green.primary = green[5];
|
|
var cyan = [
|
|
"#e6fffb",
|
|
"#b5f5ec",
|
|
"#87e8de",
|
|
"#5cdbd3",
|
|
"#36cfc9",
|
|
"#13c2c2",
|
|
"#08979c",
|
|
"#006d75",
|
|
"#00474f",
|
|
"#002329"
|
|
];
|
|
cyan.primary = cyan[5];
|
|
var blue = [
|
|
"#e6f4ff",
|
|
"#bae0ff",
|
|
"#91caff",
|
|
"#69b1ff",
|
|
"#4096ff",
|
|
"#1677ff",
|
|
"#0958d9",
|
|
"#003eb3",
|
|
"#002c8c",
|
|
"#001d66"
|
|
];
|
|
blue.primary = blue[5];
|
|
var geekblue = [
|
|
"#f0f5ff",
|
|
"#d6e4ff",
|
|
"#adc6ff",
|
|
"#85a5ff",
|
|
"#597ef7",
|
|
"#2f54eb",
|
|
"#1d39c4",
|
|
"#10239e",
|
|
"#061178",
|
|
"#030852"
|
|
];
|
|
geekblue.primary = geekblue[5];
|
|
var purple = [
|
|
"#f9f0ff",
|
|
"#efdbff",
|
|
"#d3adf7",
|
|
"#b37feb",
|
|
"#9254de",
|
|
"#722ed1",
|
|
"#531dab",
|
|
"#391085",
|
|
"#22075e",
|
|
"#120338"
|
|
];
|
|
purple.primary = purple[5];
|
|
var magenta = [
|
|
"#fff0f6",
|
|
"#ffd6e7",
|
|
"#ffadd2",
|
|
"#ff85c0",
|
|
"#f759ab",
|
|
"#eb2f96",
|
|
"#c41d7f",
|
|
"#9e1068",
|
|
"#780650",
|
|
"#520339"
|
|
];
|
|
magenta.primary = magenta[5];
|
|
var grey = [
|
|
"#a6a6a6",
|
|
"#999999",
|
|
"#8c8c8c",
|
|
"#808080",
|
|
"#737373",
|
|
"#666666",
|
|
"#404040",
|
|
"#1a1a1a",
|
|
"#000000",
|
|
"#000000"
|
|
];
|
|
grey.primary = grey[5];
|
|
var presetPalettes = {
|
|
red,
|
|
volcano,
|
|
orange,
|
|
gold,
|
|
yellow,
|
|
lime,
|
|
green,
|
|
cyan,
|
|
blue,
|
|
geekblue,
|
|
purple,
|
|
magenta,
|
|
grey
|
|
};
|
|
var redDark = [
|
|
"#2a1215",
|
|
"#431418",
|
|
"#58181c",
|
|
"#791a1f",
|
|
"#a61d24",
|
|
"#d32029",
|
|
"#e84749",
|
|
"#f37370",
|
|
"#f89f9a",
|
|
"#fac8c3"
|
|
];
|
|
redDark.primary = redDark[5];
|
|
var volcanoDark = [
|
|
"#2b1611",
|
|
"#441d12",
|
|
"#592716",
|
|
"#7c3118",
|
|
"#aa3e19",
|
|
"#d84a1b",
|
|
"#e87040",
|
|
"#f3956a",
|
|
"#f8b692",
|
|
"#fad4bc"
|
|
];
|
|
volcanoDark.primary = volcanoDark[5];
|
|
var orangeDark = [
|
|
"#2b1d11",
|
|
"#442a11",
|
|
"#593815",
|
|
"#7c4a15",
|
|
"#aa6215",
|
|
"#d87a16",
|
|
"#e89a3c",
|
|
"#f3b765",
|
|
"#f8cf8d",
|
|
"#fae3b7"
|
|
];
|
|
orangeDark.primary = orangeDark[5];
|
|
var goldDark = [
|
|
"#2b2111",
|
|
"#443111",
|
|
"#594214",
|
|
"#7c5914",
|
|
"#aa7714",
|
|
"#d89614",
|
|
"#e8b339",
|
|
"#f3cc62",
|
|
"#f8df8b",
|
|
"#faedb5"
|
|
];
|
|
goldDark.primary = goldDark[5];
|
|
var yellowDark = [
|
|
"#2b2611",
|
|
"#443b11",
|
|
"#595014",
|
|
"#7c6e14",
|
|
"#aa9514",
|
|
"#d8bd14",
|
|
"#e8d639",
|
|
"#f3ea62",
|
|
"#f8f48b",
|
|
"#fafab5"
|
|
];
|
|
yellowDark.primary = yellowDark[5];
|
|
var limeDark = [
|
|
"#1f2611",
|
|
"#2e3c10",
|
|
"#3e4f13",
|
|
"#536d13",
|
|
"#6f9412",
|
|
"#8bbb11",
|
|
"#a9d134",
|
|
"#c9e75d",
|
|
"#e4f88b",
|
|
"#f0fab5"
|
|
];
|
|
limeDark.primary = limeDark[5];
|
|
var greenDark = [
|
|
"#162312",
|
|
"#1d3712",
|
|
"#274916",
|
|
"#306317",
|
|
"#3c8618",
|
|
"#49aa19",
|
|
"#6abe39",
|
|
"#8fd460",
|
|
"#b2e58b",
|
|
"#d5f2bb"
|
|
];
|
|
greenDark.primary = greenDark[5];
|
|
var cyanDark = [
|
|
"#112123",
|
|
"#113536",
|
|
"#144848",
|
|
"#146262",
|
|
"#138585",
|
|
"#13a8a8",
|
|
"#33bcb7",
|
|
"#58d1c9",
|
|
"#84e2d8",
|
|
"#b2f1e8"
|
|
];
|
|
cyanDark.primary = cyanDark[5];
|
|
var blueDark = [
|
|
"#111a2c",
|
|
"#112545",
|
|
"#15325b",
|
|
"#15417e",
|
|
"#1554ad",
|
|
"#1668dc",
|
|
"#3c89e8",
|
|
"#65a9f3",
|
|
"#8dc5f8",
|
|
"#b7dcfa"
|
|
];
|
|
blueDark.primary = blueDark[5];
|
|
var geekblueDark = [
|
|
"#131629",
|
|
"#161d40",
|
|
"#1c2755",
|
|
"#203175",
|
|
"#263ea0",
|
|
"#2b4acb",
|
|
"#5273e0",
|
|
"#7f9ef3",
|
|
"#a8c1f8",
|
|
"#d2e0fa"
|
|
];
|
|
geekblueDark.primary = geekblueDark[5];
|
|
var purpleDark = [
|
|
"#1a1325",
|
|
"#24163a",
|
|
"#301c4d",
|
|
"#3e2069",
|
|
"#51258f",
|
|
"#642ab5",
|
|
"#854eca",
|
|
"#ab7ae0",
|
|
"#cda8f0",
|
|
"#ebd7fa"
|
|
];
|
|
purpleDark.primary = purpleDark[5];
|
|
var magentaDark = [
|
|
"#291321",
|
|
"#40162f",
|
|
"#551c3b",
|
|
"#75204f",
|
|
"#a02669",
|
|
"#cb2b83",
|
|
"#e0529c",
|
|
"#f37fb7",
|
|
"#f8a8cc",
|
|
"#fad2e3"
|
|
];
|
|
magentaDark.primary = magentaDark[5];
|
|
var greyDark = [
|
|
"#151515",
|
|
"#1f1f1f",
|
|
"#2d2d2d",
|
|
"#393939",
|
|
"#494949",
|
|
"#5a5a5a",
|
|
"#6a6a6a",
|
|
"#7b7b7b",
|
|
"#888888",
|
|
"#969696"
|
|
];
|
|
greyDark.primary = greyDark[5];
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/Dom/canUseDom.js
|
|
function canUseDom() {
|
|
return !!(typeof window !== "undefined" && window.document && window.document.createElement);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/Dom/contains.js
|
|
function contains(root, n) {
|
|
if (!root) return false;
|
|
if (root.contains) return root.contains(n);
|
|
let node = n;
|
|
while (node) {
|
|
if (node === root) return true;
|
|
node = node.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/Dom/dynamicCSS.js
|
|
var APPEND_ORDER = "data-rc-order";
|
|
var APPEND_PRIORITY = "data-rc-priority";
|
|
var MARK_KEY = `rc-util-key`;
|
|
var containerCache = /* @__PURE__ */ new Map();
|
|
function getMark({ mark } = {}) {
|
|
if (mark) return mark.startsWith("data-") ? mark : `data-${mark}`;
|
|
return MARK_KEY;
|
|
}
|
|
function getContainer(option) {
|
|
if (option.attachTo) return option.attachTo;
|
|
return document.querySelector("head") || document.body;
|
|
}
|
|
function getOrder(prepend) {
|
|
if (prepend === "queue") return "prependQueue";
|
|
return prepend ? "prepend" : "append";
|
|
}
|
|
/**
|
|
* Find style which inject by rc-util
|
|
*/
|
|
function findStyles(container) {
|
|
return Array.from((containerCache.get(container) || container).children).filter((node) => node.tagName === "STYLE");
|
|
}
|
|
function injectCSS(css, option = {}) {
|
|
if (!canUseDom()) return null;
|
|
const { csp, prepend, priority = 0 } = option;
|
|
const mergedOrder = getOrder(prepend);
|
|
const isPrependQueue = mergedOrder === "prependQueue";
|
|
const styleNode = document.createElement("style");
|
|
styleNode.setAttribute(APPEND_ORDER, mergedOrder);
|
|
if (isPrependQueue && priority) styleNode.setAttribute(APPEND_PRIORITY, `${priority}`);
|
|
if (csp?.nonce) styleNode.nonce = csp?.nonce;
|
|
styleNode.innerHTML = css;
|
|
const container = getContainer(option);
|
|
const { firstChild } = container;
|
|
if (prepend) {
|
|
if (isPrependQueue) {
|
|
const existStyle = (option.styles || findStyles(container)).filter((node) => {
|
|
if (!["prepend", "prependQueue"].includes(node.getAttribute(APPEND_ORDER))) return false;
|
|
return priority >= Number(node.getAttribute(APPEND_PRIORITY) || 0);
|
|
});
|
|
if (existStyle.length) {
|
|
container.insertBefore(styleNode, existStyle[existStyle.length - 1].nextSibling);
|
|
return styleNode;
|
|
}
|
|
}
|
|
container.insertBefore(styleNode, firstChild);
|
|
} else container.appendChild(styleNode);
|
|
return styleNode;
|
|
}
|
|
function findExistNode(key, option = {}) {
|
|
let { styles } = option;
|
|
styles ||= findStyles(getContainer(option));
|
|
return styles.find((node) => node.getAttribute(getMark(option)) === key);
|
|
}
|
|
function removeCSS(key, option = {}) {
|
|
const existNode = findExistNode(key, option);
|
|
if (existNode) getContainer(option).removeChild(existNode);
|
|
}
|
|
/**
|
|
* qiankun will inject `appendChild` to insert into other
|
|
*/
|
|
function syncRealContainer(container, option) {
|
|
const cachedRealContainer = containerCache.get(container);
|
|
if (!cachedRealContainer || !contains(document, cachedRealContainer)) {
|
|
const placeholderStyle = injectCSS("", option);
|
|
const { parentNode } = placeholderStyle;
|
|
containerCache.set(container, parentNode);
|
|
container.removeChild(placeholderStyle);
|
|
}
|
|
}
|
|
function updateCSS(css, key, originOption = {}) {
|
|
const container = getContainer(originOption);
|
|
const styles = findStyles(container);
|
|
const option = {
|
|
...originOption,
|
|
styles
|
|
};
|
|
syncRealContainer(container, option);
|
|
const existNode = findExistNode(key, option);
|
|
if (existNode) {
|
|
if (option.csp?.nonce && existNode.nonce !== option.csp?.nonce) existNode.nonce = option.csp?.nonce;
|
|
if (existNode.innerHTML !== css) existNode.innerHTML = css;
|
|
return existNode;
|
|
}
|
|
const newNode = injectCSS(css, option);
|
|
newNode.setAttribute(getMark(option), key);
|
|
return newNode;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/Dom/shadow.js
|
|
function getRoot(ele) {
|
|
return ele?.getRootNode?.();
|
|
}
|
|
/**
|
|
* Check if is in shadowRoot
|
|
*/
|
|
function inShadow(ele) {
|
|
return getRoot(ele) instanceof ShadowRoot;
|
|
}
|
|
/**
|
|
* Return shadowRoot if possible
|
|
*/
|
|
function getShadowRoot(ele) {
|
|
return inShadow(ele) ? getRoot(ele) : null;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/warning.js
|
|
var warned = {};
|
|
var preWarningFns = [];
|
|
/**
|
|
* Pre warning enable you to parse content before console.error.
|
|
* Modify to null will prevent warning.
|
|
*/
|
|
var preMessage = (fn) => {
|
|
preWarningFns.push(fn);
|
|
};
|
|
/**
|
|
* Warning if condition not match.
|
|
* @param valid Condition
|
|
* @param message Warning message
|
|
* @example
|
|
* ```js
|
|
* warning(false, 'some error'); // print some error
|
|
* warning(true, 'some error'); // print nothing
|
|
* warning(1 === 2, 'some error'); // print some error
|
|
* ```
|
|
*/
|
|
function warning$1(valid, message) {
|
|
if (!valid && console !== void 0) {
|
|
const finalMessage = preWarningFns.reduce((msg, preMessageFn) => preMessageFn(msg ?? "", "warning"), message);
|
|
if (finalMessage) console.error(`Warning: ${finalMessage}`);
|
|
}
|
|
}
|
|
/** @see Similar to {@link warning} */
|
|
function note(valid, message) {
|
|
if (!valid && console !== void 0) {
|
|
const finalMessage = preWarningFns.reduce((msg, preMessageFn) => preMessageFn(msg ?? "", "note"), message);
|
|
if (finalMessage) console.warn(`Note: ${finalMessage}`);
|
|
}
|
|
}
|
|
function resetWarned() {
|
|
warned = {};
|
|
}
|
|
function call(method, valid, message) {
|
|
if (!valid && !warned[message]) {
|
|
method(false, message);
|
|
warned[message] = true;
|
|
}
|
|
}
|
|
/** @see Same as {@link warning}, but only warn once for the same message */
|
|
function warningOnce(valid, message) {
|
|
call(warning$1, valid, message);
|
|
}
|
|
/** @see Same as {@link warning}, but only warn once for the same message */
|
|
function noteOnce(valid, message) {
|
|
call(note, valid, message);
|
|
}
|
|
warningOnce.preMessage = preMessage;
|
|
warningOnce.resetWarned = resetWarned;
|
|
warningOnce.noteOnce = noteOnce;
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/utils.js
|
|
function camelCase(input) {
|
|
return input.replace(/-(.)/g, (match, g) => g.toUpperCase());
|
|
}
|
|
function warning(valid, message) {
|
|
warningOnce(valid, `[@ant-design/icons] ${message}`);
|
|
}
|
|
function isIconDefinition(target) {
|
|
return typeof target === "object" && typeof target.name === "string" && typeof target.theme === "string" && (typeof target.icon === "object" || typeof target.icon === "function");
|
|
}
|
|
function normalizeAttrs(attrs = {}) {
|
|
return Object.keys(attrs).reduce((acc, key) => {
|
|
const val = attrs[key];
|
|
switch (key) {
|
|
case "class":
|
|
acc.className = val;
|
|
delete acc.class;
|
|
break;
|
|
default:
|
|
delete acc[key];
|
|
acc[camelCase(key)] = val;
|
|
}
|
|
return acc;
|
|
}, {});
|
|
}
|
|
function generate(node, key, rootProps) {
|
|
if (!rootProps) return /* @__PURE__ */ import_react.createElement(node.tag, {
|
|
key,
|
|
...normalizeAttrs(node.attrs)
|
|
}, (node.children || []).map((child, index) => generate(child, `${key}-${node.tag}-${index}`)));
|
|
return /* @__PURE__ */ import_react.createElement(node.tag, {
|
|
key,
|
|
...normalizeAttrs(node.attrs),
|
|
...rootProps
|
|
}, (node.children || []).map((child, index) => generate(child, `${key}-${node.tag}-${index}`)));
|
|
}
|
|
function getSecondaryColor(primaryColor) {
|
|
return generate$1(primaryColor)[0];
|
|
}
|
|
function normalizeTwoToneColors(twoToneColor) {
|
|
if (!twoToneColor) return [];
|
|
return Array.isArray(twoToneColor) ? twoToneColor : [twoToneColor];
|
|
}
|
|
var svgBaseProps = {
|
|
width: "1em",
|
|
height: "1em",
|
|
fill: "currentColor",
|
|
"aria-hidden": "true",
|
|
focusable: "false"
|
|
};
|
|
var iconStyles = `
|
|
.anticon {
|
|
display: inline-flex;
|
|
align-items: center;
|
|
color: inherit;
|
|
font-style: normal;
|
|
line-height: 0;
|
|
text-align: center;
|
|
text-transform: none;
|
|
vertical-align: -0.125em;
|
|
text-rendering: optimizeLegibility;
|
|
-webkit-font-smoothing: antialiased;
|
|
-moz-osx-font-smoothing: grayscale;
|
|
}
|
|
|
|
.anticon > * {
|
|
line-height: 1;
|
|
}
|
|
|
|
.anticon svg {
|
|
display: inline-block;
|
|
vertical-align: inherit;
|
|
}
|
|
|
|
.anticon::before {
|
|
display: none;
|
|
}
|
|
|
|
.anticon .anticon-icon {
|
|
display: block;
|
|
}
|
|
|
|
.anticon[tabindex] {
|
|
cursor: pointer;
|
|
}
|
|
|
|
.anticon-spin {
|
|
-webkit-animation: loadingCircle 1s infinite linear;
|
|
animation: loadingCircle 1s infinite linear;
|
|
}
|
|
|
|
@-webkit-keyframes loadingCircle {
|
|
100% {
|
|
-webkit-transform: rotate(360deg);
|
|
transform: rotate(360deg);
|
|
}
|
|
}
|
|
|
|
@keyframes loadingCircle {
|
|
100% {
|
|
-webkit-transform: rotate(360deg);
|
|
transform: rotate(360deg);
|
|
}
|
|
}
|
|
`;
|
|
var useInsertStyles = (eleRef) => {
|
|
const { csp, prefixCls, layer } = (0, import_react.useContext)(IconContext);
|
|
let mergedStyleStr = iconStyles;
|
|
if (prefixCls) mergedStyleStr = mergedStyleStr.replace(/anticon/g, prefixCls);
|
|
if (layer) mergedStyleStr = `@layer ${layer} {\n${mergedStyleStr}\n}`;
|
|
(0, import_react.useEffect)(() => {
|
|
const ele = eleRef.current;
|
|
const shadowRoot = getShadowRoot(ele);
|
|
updateCSS(mergedStyleStr, "@ant-design-icons", {
|
|
prepend: !layer,
|
|
csp,
|
|
attachTo: shadowRoot
|
|
});
|
|
}, []);
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/components/IconBase.js
|
|
var twoToneColorPalette = {
|
|
primaryColor: "#333",
|
|
secondaryColor: "#E6E6E6",
|
|
calculated: false
|
|
};
|
|
function setTwoToneColors({ primaryColor, secondaryColor }) {
|
|
twoToneColorPalette.primaryColor = primaryColor;
|
|
twoToneColorPalette.secondaryColor = secondaryColor || getSecondaryColor(primaryColor);
|
|
twoToneColorPalette.calculated = !!secondaryColor;
|
|
}
|
|
function getTwoToneColors() {
|
|
return { ...twoToneColorPalette };
|
|
}
|
|
var IconBase = (props) => {
|
|
const { icon, className, onClick, style, primaryColor, secondaryColor, ...restProps } = props;
|
|
const svgRef = import_react.useRef(null);
|
|
let colors = twoToneColorPalette;
|
|
if (primaryColor) colors = {
|
|
primaryColor,
|
|
secondaryColor: secondaryColor || getSecondaryColor(primaryColor)
|
|
};
|
|
useInsertStyles(svgRef);
|
|
warning(isIconDefinition(icon), `icon should be icon definiton, but got ${icon}`);
|
|
if (!isIconDefinition(icon)) return null;
|
|
let target = icon;
|
|
if (target && typeof target.icon === "function") target = {
|
|
...target,
|
|
icon: target.icon(colors.primaryColor, colors.secondaryColor)
|
|
};
|
|
return generate(target.icon, `svg-${target.name}`, {
|
|
className,
|
|
onClick,
|
|
style,
|
|
"data-icon": target.name,
|
|
width: "1em",
|
|
height: "1em",
|
|
fill: "currentColor",
|
|
"aria-hidden": "true",
|
|
...restProps,
|
|
ref: svgRef
|
|
});
|
|
};
|
|
IconBase.displayName = "IconReact";
|
|
IconBase.getTwoToneColors = getTwoToneColors;
|
|
IconBase.setTwoToneColors = setTwoToneColors;
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/components/twoTonePrimaryColor.js
|
|
function setTwoToneColor(twoToneColor) {
|
|
const [primaryColor, secondaryColor] = normalizeTwoToneColors(twoToneColor);
|
|
return IconBase.setTwoToneColors({
|
|
primaryColor,
|
|
secondaryColor
|
|
});
|
|
}
|
|
function getTwoToneColor() {
|
|
const colors = IconBase.getTwoToneColors();
|
|
if (!colors.calculated) return colors.primaryColor;
|
|
return [colors.primaryColor, colors.secondaryColor];
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/components/AntdIcon.js
|
|
function _extends$52() {
|
|
_extends$52 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$52.apply(this, arguments);
|
|
}
|
|
setTwoToneColor(blue.primary);
|
|
var Icon = /* @__PURE__ */ import_react.forwardRef((props, ref) => {
|
|
const { className, icon, spin, rotate, tabIndex, onClick, twoToneColor, ...restProps } = props;
|
|
const { prefixCls = "anticon", rootClassName } = import_react.useContext(IconContext);
|
|
const classString = clsx(rootClassName, prefixCls, {
|
|
[`${prefixCls}-${icon.name}`]: !!icon.name,
|
|
[`${prefixCls}-spin`]: !!spin || icon.name === "loading"
|
|
}, className);
|
|
let iconTabIndex = tabIndex;
|
|
if (iconTabIndex === void 0 && onClick) iconTabIndex = -1;
|
|
const svgStyle = rotate ? {
|
|
msTransform: `rotate(${rotate}deg)`,
|
|
transform: `rotate(${rotate}deg)`
|
|
} : void 0;
|
|
const [primaryColor, secondaryColor] = normalizeTwoToneColors(twoToneColor);
|
|
return /* @__PURE__ */ import_react.createElement("span", _extends$52({
|
|
role: "img",
|
|
"aria-label": icon.name
|
|
}, restProps, {
|
|
ref,
|
|
tabIndex: iconTabIndex,
|
|
onClick,
|
|
className: classString
|
|
}), /* @__PURE__ */ import_react.createElement(IconBase, {
|
|
icon,
|
|
primaryColor,
|
|
secondaryColor,
|
|
style: svgStyle
|
|
}));
|
|
});
|
|
Icon.getTwoToneColor = getTwoToneColor;
|
|
Icon.setTwoToneColor = setTwoToneColor;
|
|
Icon.displayName = "AntdIcon";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/BarsOutlined.js
|
|
var BarsOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "0 0 1024 1024",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M912 192H328c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h584c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zm0 284H328c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h584c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zm0 284H328c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h584c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zM104 228a56 56 0 10112 0 56 56 0 10-112 0zm0 284a56 56 0 10112 0 56 56 0 10-112 0zm0 284a56 56 0 10112 0 56 56 0 10-112 0z" }
|
|
}]
|
|
},
|
|
"name": "bars",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/BarsOutlined.js
|
|
function _extends$51() {
|
|
_extends$51 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$51.apply(this, arguments);
|
|
}
|
|
var BarsOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$51({}, props, {
|
|
ref,
|
|
icon: BarsOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$51 = /* @__PURE__ */ import_react.forwardRef(BarsOutlined);
|
|
RefIcon$51.displayName = "BarsOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CalendarOutlined.js
|
|
var CalendarOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M880 184H712v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H384v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H144c-17.7 0-32 14.3-32 32v664c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V216c0-17.7-14.3-32-32-32zm-40 656H184V460h656v380zM184 392V256h128v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h256v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h128v136H184z" }
|
|
}]
|
|
},
|
|
"name": "calendar",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CalendarOutlined.js
|
|
function _extends$50() {
|
|
_extends$50 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$50.apply(this, arguments);
|
|
}
|
|
var CalendarOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$50({}, props, {
|
|
ref,
|
|
icon: CalendarOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$50 = /* @__PURE__ */ import_react.forwardRef(CalendarOutlined);
|
|
RefIcon$50.displayName = "CalendarOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CaretDownFilled.js
|
|
var CaretDownFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "0 0 1024 1024",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M840.4 300H183.6c-19.7 0-30.7 20.8-18.5 35l328.4 380.8c9.4 10.9 27.5 10.9 37 0L858.9 335c12.2-14.2 1.2-35-18.5-35z" }
|
|
}]
|
|
},
|
|
"name": "caret-down",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CaretDownFilled.js
|
|
function _extends$49() {
|
|
_extends$49 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$49.apply(this, arguments);
|
|
}
|
|
var CaretDownFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$49({}, props, {
|
|
ref,
|
|
icon: CaretDownFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$49 = /* @__PURE__ */ import_react.forwardRef(CaretDownFilled);
|
|
RefIcon$49.displayName = "CaretDownFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CaretDownOutlined.js
|
|
var CaretDownOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "0 0 1024 1024",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M840.4 300H183.6c-19.7 0-30.7 20.8-18.5 35l328.4 380.8c9.4 10.9 27.5 10.9 37 0L858.9 335c12.2-14.2 1.2-35-18.5-35z" }
|
|
}]
|
|
},
|
|
"name": "caret-down",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CaretDownOutlined.js
|
|
function _extends$48() {
|
|
_extends$48 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$48.apply(this, arguments);
|
|
}
|
|
var CaretDownOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$48({}, props, {
|
|
ref,
|
|
icon: CaretDownOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$48 = /* @__PURE__ */ import_react.forwardRef(CaretDownOutlined);
|
|
RefIcon$48.displayName = "CaretDownOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CaretUpOutlined.js
|
|
var CaretUpOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "0 0 1024 1024",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M858.9 689L530.5 308.2c-9.4-10.9-27.5-10.9-37 0L165.1 689c-12.2 14.2-1.2 35 18.5 35h656.8c19.7 0 30.7-20.8 18.5-35z" }
|
|
}]
|
|
},
|
|
"name": "caret-up",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CaretUpOutlined.js
|
|
function _extends$47() {
|
|
_extends$47 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$47.apply(this, arguments);
|
|
}
|
|
var CaretUpOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$47({}, props, {
|
|
ref,
|
|
icon: CaretUpOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$47 = /* @__PURE__ */ import_react.forwardRef(CaretUpOutlined);
|
|
RefIcon$47.displayName = "CaretUpOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CheckCircleFilled.js
|
|
var CheckCircleFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm193.5 301.7l-210.6 292a31.8 31.8 0 01-51.7 0L318.5 484.9c-3.8-5.3 0-12.7 6.5-12.7h46.9c10.2 0 19.9 4.9 25.9 13.3l71.2 98.8 157.2-218c6-8.3 15.6-13.3 25.9-13.3H699c6.5 0 10.3 7.4 6.5 12.7z" }
|
|
}]
|
|
},
|
|
"name": "check-circle",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CheckCircleFilled.js
|
|
function _extends$46() {
|
|
_extends$46 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$46.apply(this, arguments);
|
|
}
|
|
var CheckCircleFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$46({}, props, {
|
|
ref,
|
|
icon: CheckCircleFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$46 = /* @__PURE__ */ import_react.forwardRef(CheckCircleFilled);
|
|
RefIcon$46.displayName = "CheckCircleFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CheckOutlined.js
|
|
var CheckOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M912 190h-69.9c-9.8 0-19.1 4.5-25.1 12.2L404.7 724.5 207 474a32 32 0 00-25.1-12.2H112c-6.7 0-10.4 7.7-6.3 12.9l273.9 347c12.8 16.2 37.4 16.2 50.3 0l488.4-618.9c4.1-5.1.4-12.8-6.3-12.8z" }
|
|
}]
|
|
},
|
|
"name": "check",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CheckOutlined.js
|
|
function _extends$45() {
|
|
_extends$45 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$45.apply(this, arguments);
|
|
}
|
|
var CheckOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$45({}, props, {
|
|
ref,
|
|
icon: CheckOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$45 = /* @__PURE__ */ import_react.forwardRef(CheckOutlined);
|
|
RefIcon$45.displayName = "CheckOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/ClockCircleOutlined.js
|
|
var ClockCircleOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" }
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": { "d": "M686.7 638.6L544.1 535.5V288c0-4.4-3.6-8-8-8H488c-4.4 0-8 3.6-8 8v275.4c0 2.6 1.2 5 3.3 6.5l165.4 120.6c3.6 2.6 8.6 1.8 11.2-1.7l28.6-39c2.6-3.7 1.8-8.7-1.8-11.2z" }
|
|
}]
|
|
},
|
|
"name": "clock-circle",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/ClockCircleOutlined.js
|
|
function _extends$44() {
|
|
_extends$44 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$44.apply(this, arguments);
|
|
}
|
|
var ClockCircleOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$44({}, props, {
|
|
ref,
|
|
icon: ClockCircleOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$44 = /* @__PURE__ */ import_react.forwardRef(ClockCircleOutlined);
|
|
RefIcon$44.displayName = "ClockCircleOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CloseCircleFilled.js
|
|
var CloseCircleFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"fill-rule": "evenodd",
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M512 64c247.4 0 448 200.6 448 448S759.4 960 512 960 64 759.4 64 512 264.6 64 512 64zm127.98 274.82h-.04l-.08.06L512 466.75 384.14 338.88c-.04-.05-.06-.06-.08-.06a.12.12 0 00-.07 0c-.03 0-.05.01-.09.05l-45.02 45.02a.2.2 0 00-.05.09.12.12 0 000 .07v.02a.27.27 0 00.06.06L466.75 512 338.88 639.86c-.05.04-.06.06-.06.08a.12.12 0 000 .07c0 .03.01.05.05.09l45.02 45.02a.2.2 0 00.09.05.12.12 0 00.07 0c.02 0 .04-.01.08-.05L512 557.25l127.86 127.87c.04.04.06.05.08.05a.12.12 0 00.07 0c.03 0 .05-.01.09-.05l45.02-45.02a.2.2 0 00.05-.09.12.12 0 000-.07v-.02a.27.27 0 00-.05-.06L557.25 512l127.87-127.86c.04-.04.05-.06.05-.08a.12.12 0 000-.07c0-.03-.01-.05-.05-.09l-45.02-45.02a.2.2 0 00-.09-.05.12.12 0 00-.07 0z" }
|
|
}]
|
|
},
|
|
"name": "close-circle",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CloseCircleFilled.js
|
|
function _extends$43() {
|
|
_extends$43 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$43.apply(this, arguments);
|
|
}
|
|
var CloseCircleFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$43({}, props, {
|
|
ref,
|
|
icon: CloseCircleFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$43 = /* @__PURE__ */ import_react.forwardRef(CloseCircleFilled);
|
|
RefIcon$43.displayName = "CloseCircleFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CloseOutlined.js
|
|
var CloseOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"fill-rule": "evenodd",
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M799.86 166.31c.02 0 .04.02.08.06l57.69 57.7c.04.03.05.05.06.08a.12.12 0 010 .06c0 .03-.02.05-.06.09L569.93 512l287.7 287.7c.04.04.05.06.06.09a.12.12 0 010 .07c0 .02-.02.04-.06.08l-57.7 57.69c-.03.04-.05.05-.07.06a.12.12 0 01-.07 0c-.03 0-.05-.02-.09-.06L512 569.93l-287.7 287.7c-.04.04-.06.05-.09.06a.12.12 0 01-.07 0c-.02 0-.04-.02-.08-.06l-57.69-57.7c-.04-.03-.05-.05-.06-.07a.12.12 0 010-.07c0-.03.02-.05.06-.09L454.07 512l-287.7-287.7c-.04-.04-.05-.06-.06-.09a.12.12 0 010-.07c0-.02.02-.04.06-.08l57.7-57.69c.03-.04.05-.05.07-.06a.12.12 0 01.07 0c.03 0 .05.02.09.06L512 454.07l287.7-287.7c.04-.04.06-.05.09-.06a.12.12 0 01.07 0z" }
|
|
}]
|
|
},
|
|
"name": "close",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CloseOutlined.js
|
|
function _extends$42() {
|
|
_extends$42 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$42.apply(this, arguments);
|
|
}
|
|
var CloseOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$42({}, props, {
|
|
ref,
|
|
icon: CloseOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$42 = /* @__PURE__ */ import_react.forwardRef(CloseOutlined);
|
|
RefIcon$42.displayName = "CloseOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/CopyOutlined.js
|
|
var CopyOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M832 64H296c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h496v688c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8V96c0-17.7-14.3-32-32-32zM704 192H192c-17.7 0-32 14.3-32 32v530.7c0 8.5 3.4 16.6 9.4 22.6l173.3 173.3c2.2 2.2 4.7 4 7.4 5.5v1.9h4.2c3.5 1.3 7.2 2 11 2H704c17.7 0 32-14.3 32-32V224c0-17.7-14.3-32-32-32zM350 856.2L263.9 770H350v86.2zM664 888H414V746c0-22.1-17.9-40-40-40H232V264h432v624z" }
|
|
}]
|
|
},
|
|
"name": "copy",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/CopyOutlined.js
|
|
function _extends$41() {
|
|
_extends$41 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$41.apply(this, arguments);
|
|
}
|
|
var CopyOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$41({}, props, {
|
|
ref,
|
|
icon: CopyOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$41 = /* @__PURE__ */ import_react.forwardRef(CopyOutlined);
|
|
RefIcon$41.displayName = "CopyOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/DeleteOutlined.js
|
|
var DeleteOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M360 184h-8c4.4 0 8-3.6 8-8v8h304v-8c0 4.4 3.6 8 8 8h-8v72h72v-80c0-35.3-28.7-64-64-64H352c-35.3 0-64 28.7-64 64v80h72v-72zm504 72H160c-17.7 0-32 14.3-32 32v32c0 4.4 3.6 8 8 8h60.4l24.7 523c1.6 34.1 29.8 61 63.9 61h454c34.2 0 62.3-26.8 63.9-61l24.7-523H888c4.4 0 8-3.6 8-8v-32c0-17.7-14.3-32-32-32zM731.3 840H292.7l-24.2-512h487l-24.2 512z" }
|
|
}]
|
|
},
|
|
"name": "delete",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/DeleteOutlined.js
|
|
function _extends$40() {
|
|
_extends$40 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$40.apply(this, arguments);
|
|
}
|
|
var DeleteOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$40({}, props, {
|
|
ref,
|
|
icon: DeleteOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$40 = /* @__PURE__ */ import_react.forwardRef(DeleteOutlined);
|
|
RefIcon$40.displayName = "DeleteOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/DoubleLeftOutlined.js
|
|
var DoubleLeftOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M272.9 512l265.4-339.1c4.1-5.2.4-12.9-6.3-12.9h-77.3c-4.9 0-9.6 2.3-12.6 6.1L186.8 492.3a31.99 31.99 0 000 39.5l255.3 326.1c3 3.9 7.7 6.1 12.6 6.1H532c6.7 0 10.4-7.7 6.3-12.9L272.9 512zm304 0l265.4-339.1c4.1-5.2.4-12.9-6.3-12.9h-77.3c-4.9 0-9.6 2.3-12.6 6.1L490.8 492.3a31.99 31.99 0 000 39.5l255.3 326.1c3 3.9 7.7 6.1 12.6 6.1H836c6.7 0 10.4-7.7 6.3-12.9L576.9 512z" }
|
|
}]
|
|
},
|
|
"name": "double-left",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/DoubleLeftOutlined.js
|
|
function _extends$39() {
|
|
_extends$39 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$39.apply(this, arguments);
|
|
}
|
|
var DoubleLeftOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$39({}, props, {
|
|
ref,
|
|
icon: DoubleLeftOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$39 = /* @__PURE__ */ import_react.forwardRef(DoubleLeftOutlined);
|
|
RefIcon$39.displayName = "DoubleLeftOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/DoubleRightOutlined.js
|
|
var DoubleRightOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M533.2 492.3L277.9 166.1c-3-3.9-7.7-6.1-12.6-6.1H188c-6.7 0-10.4 7.7-6.3 12.9L447.1 512 181.7 851.1A7.98 7.98 0 00188 864h77.3c4.9 0 9.6-2.3 12.6-6.1l255.3-326.1c9.1-11.7 9.1-27.9 0-39.5zm304 0L581.9 166.1c-3-3.9-7.7-6.1-12.6-6.1H492c-6.7 0-10.4 7.7-6.3 12.9L751.1 512 485.7 851.1A7.98 7.98 0 00492 864h77.3c4.9 0 9.6-2.3 12.6-6.1l255.3-326.1c9.1-11.7 9.1-27.9 0-39.5z" }
|
|
}]
|
|
},
|
|
"name": "double-right",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/DoubleRightOutlined.js
|
|
function _extends$38() {
|
|
_extends$38 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$38.apply(this, arguments);
|
|
}
|
|
var DoubleRightOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$38({}, props, {
|
|
ref,
|
|
icon: DoubleRightOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$38 = /* @__PURE__ */ import_react.forwardRef(DoubleRightOutlined);
|
|
RefIcon$38.displayName = "DoubleRightOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/DownOutlined.js
|
|
var DownOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z" }
|
|
}]
|
|
},
|
|
"name": "down",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/DownOutlined.js
|
|
function _extends$37() {
|
|
_extends$37 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$37.apply(this, arguments);
|
|
}
|
|
var DownOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$37({}, props, {
|
|
ref,
|
|
icon: DownOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$37 = /* @__PURE__ */ import_react.forwardRef(DownOutlined);
|
|
RefIcon$37.displayName = "DownOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/DownloadOutlined.js
|
|
var DownloadOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M505.7 661a8 8 0 0012.6 0l112-141.7c4.1-5.2.4-12.9-6.3-12.9h-74.1V168c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v338.3H400c-6.7 0-10.4 7.7-6.3 12.9l112 141.8zM878 626h-60c-4.4 0-8 3.6-8 8v154H214V634c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v198c0 17.7 14.3 32 32 32h684c17.7 0 32-14.3 32-32V634c0-4.4-3.6-8-8-8z" }
|
|
}]
|
|
},
|
|
"name": "download",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/DownloadOutlined.js
|
|
function _extends$36() {
|
|
_extends$36 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$36.apply(this, arguments);
|
|
}
|
|
var DownloadOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$36({}, props, {
|
|
ref,
|
|
icon: DownloadOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$36 = /* @__PURE__ */ import_react.forwardRef(DownloadOutlined);
|
|
RefIcon$36.displayName = "DownloadOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/EditOutlined.js
|
|
var EditOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M257.7 752c2 0 4-.2 6-.5L431.9 722c2-.4 3.9-1.3 5.3-2.8l423.9-423.9a9.96 9.96 0 000-14.1L694.9 114.9c-1.9-1.9-4.4-2.9-7.1-2.9s-5.2 1-7.1 2.9L256.8 538.8c-1.5 1.5-2.4 3.3-2.8 5.3l-29.5 168.2a33.5 33.5 0 009.4 29.8c6.6 6.4 14.9 9.9 23.8 9.9zm67.4-174.4L687.8 215l73.3 73.3-362.7 362.6-88.9 15.7 15.6-89zM880 836H144c-17.7 0-32 14.3-32 32v36c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-36c0-17.7-14.3-32-32-32z" }
|
|
}]
|
|
},
|
|
"name": "edit",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/EditOutlined.js
|
|
function _extends$35() {
|
|
_extends$35 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$35.apply(this, arguments);
|
|
}
|
|
var EditOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$35({}, props, {
|
|
ref,
|
|
icon: EditOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$35 = /* @__PURE__ */ import_react.forwardRef(EditOutlined);
|
|
RefIcon$35.displayName = "EditOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/EllipsisOutlined.js
|
|
var EllipsisOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M176 511a56 56 0 10112 0 56 56 0 10-112 0zm280 0a56 56 0 10112 0 56 56 0 10-112 0zm280 0a56 56 0 10112 0 56 56 0 10-112 0z" }
|
|
}]
|
|
},
|
|
"name": "ellipsis",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/EllipsisOutlined.js
|
|
function _extends$34() {
|
|
_extends$34 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$34.apply(this, arguments);
|
|
}
|
|
var EllipsisOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$34({}, props, {
|
|
ref,
|
|
icon: EllipsisOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$34 = /* @__PURE__ */ import_react.forwardRef(EllipsisOutlined);
|
|
RefIcon$34.displayName = "EllipsisOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/EnterOutlined.js
|
|
var EnterOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M864 170h-60c-4.4 0-8 3.6-8 8v518H310v-73c0-6.7-7.8-10.5-13-6.3l-141.9 112a8 8 0 000 12.6l141.9 112c5.3 4.2 13 .4 13-6.3v-75h498c35.3 0 64-28.7 64-64V178c0-4.4-3.6-8-8-8z" }
|
|
}]
|
|
},
|
|
"name": "enter",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/EnterOutlined.js
|
|
function _extends$33() {
|
|
_extends$33 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$33.apply(this, arguments);
|
|
}
|
|
var EnterOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$33({}, props, {
|
|
ref,
|
|
icon: EnterOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$33 = /* @__PURE__ */ import_react.forwardRef(EnterOutlined);
|
|
RefIcon$33.displayName = "EnterOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/ExclamationCircleFilled.js
|
|
var ExclamationCircleFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm-32 232c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V296zm32 440a48.01 48.01 0 010-96 48.01 48.01 0 010 96z" }
|
|
}]
|
|
},
|
|
"name": "exclamation-circle",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/ExclamationCircleFilled.js
|
|
function _extends$32() {
|
|
_extends$32 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$32.apply(this, arguments);
|
|
}
|
|
var ExclamationCircleFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$32({}, props, {
|
|
ref,
|
|
icon: ExclamationCircleFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$32 = /* @__PURE__ */ import_react.forwardRef(ExclamationCircleFilled);
|
|
RefIcon$32.displayName = "ExclamationCircleFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/EyeInvisibleOutlined.js
|
|
var EyeInvisibleOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M942.2 486.2Q889.47 375.11 816.7 305l-50.88 50.88C807.31 395.53 843.45 447.4 874.7 512 791.5 684.2 673.4 766 512 766q-72.67 0-133.87-22.38L323 798.75Q408 838 512 838q288.3 0 430.2-300.3a60.29 60.29 0 000-51.5zm-63.57-320.64L836 122.88a8 8 0 00-11.32 0L715.31 232.2Q624.86 186 512 186q-288.3 0-430.2 300.3a60.3 60.3 0 000 51.5q56.69 119.4 136.5 191.41L112.48 835a8 8 0 000 11.31L155.17 889a8 8 0 0011.31 0l712.15-712.12a8 8 0 000-11.32zM149.3 512C232.6 339.8 350.7 258 512 258c54.54 0 104.13 9.36 149.12 28.39l-70.3 70.3a176 176 0 00-238.13 238.13l-83.42 83.42C223.1 637.49 183.3 582.28 149.3 512zm246.7 0a112.11 112.11 0 01146.2-106.69L401.31 546.2A112 112 0 01396 512z" }
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": { "d": "M508 624c-3.46 0-6.87-.16-10.25-.47l-52.82 52.82a176.09 176.09 0 00227.42-227.42l-52.82 52.82c.31 3.38.47 6.79.47 10.25a111.94 111.94 0 01-112 112z" }
|
|
}]
|
|
},
|
|
"name": "eye-invisible",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/EyeInvisibleOutlined.js
|
|
function _extends$31() {
|
|
_extends$31 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$31.apply(this, arguments);
|
|
}
|
|
var EyeInvisibleOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$31({}, props, {
|
|
ref,
|
|
icon: EyeInvisibleOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$31 = /* @__PURE__ */ import_react.forwardRef(EyeInvisibleOutlined);
|
|
RefIcon$31.displayName = "EyeInvisibleOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/EyeOutlined.js
|
|
var EyeOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M942.2 486.2C847.4 286.5 704.1 186 512 186c-192.2 0-335.4 100.5-430.2 300.3a60.3 60.3 0 000 51.5C176.6 737.5 319.9 838 512 838c192.2 0 335.4-100.5 430.2-300.3 7.7-16.2 7.7-35 0-51.5zM512 766c-161.3 0-279.4-81.8-362.7-254C232.6 339.8 350.7 258 512 258c161.3 0 279.4 81.8 362.7 254C791.5 684.2 673.4 766 512 766zm-4-430c-97.2 0-176 78.8-176 176s78.8 176 176 176 176-78.8 176-176-78.8-176-176-176zm0 288c-61.9 0-112-50.1-112-112s50.1-112 112-112 112 50.1 112 112-50.1 112-112 112z" }
|
|
}]
|
|
},
|
|
"name": "eye",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/EyeOutlined.js
|
|
function _extends$30() {
|
|
_extends$30 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$30.apply(this, arguments);
|
|
}
|
|
var EyeOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$30({}, props, {
|
|
ref,
|
|
icon: EyeOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$30 = /* @__PURE__ */ import_react.forwardRef(EyeOutlined);
|
|
RefIcon$30.displayName = "EyeOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/FileOutlined.js
|
|
var FileOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326zm1.8 562H232V136h302v216a42 42 0 0042 42h216v494z" }
|
|
}]
|
|
},
|
|
"name": "file",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/FileOutlined.js
|
|
function _extends$29() {
|
|
_extends$29 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$29.apply(this, arguments);
|
|
}
|
|
var FileOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$29({}, props, {
|
|
ref,
|
|
icon: FileOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$29 = /* @__PURE__ */ import_react.forwardRef(FileOutlined);
|
|
RefIcon$29.displayName = "FileOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/FileTextOutlined.js
|
|
var FileTextOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326zm1.8 562H232V136h302v216a42 42 0 0042 42h216v494zM504 618H320c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8h184c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8zM312 490v48c0 4.4 3.6 8 8 8h384c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H320c-4.4 0-8 3.6-8 8z" }
|
|
}]
|
|
},
|
|
"name": "file-text",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/FileTextOutlined.js
|
|
function _extends$28() {
|
|
_extends$28 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$28.apply(this, arguments);
|
|
}
|
|
var FileTextOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$28({}, props, {
|
|
ref,
|
|
icon: FileTextOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$28 = /* @__PURE__ */ import_react.forwardRef(FileTextOutlined);
|
|
RefIcon$28.displayName = "FileTextOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/FileTwoTone.js
|
|
var FileTwoTone$1 = {
|
|
"icon": function render(primaryColor, secondaryColor) {
|
|
return {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M534 352V136H232v752h560V394H576a42 42 0 01-42-42z",
|
|
"fill": secondaryColor
|
|
}
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM602 137.8L790.2 326H602V137.8zM792 888H232V136h302v216a42 42 0 0042 42h216v494z",
|
|
"fill": primaryColor
|
|
}
|
|
}]
|
|
};
|
|
},
|
|
"name": "file",
|
|
"theme": "twotone"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/FileTwoTone.js
|
|
function _extends$27() {
|
|
_extends$27 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$27.apply(this, arguments);
|
|
}
|
|
var FileTwoTone = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$27({}, props, {
|
|
ref,
|
|
icon: FileTwoTone$1
|
|
}));
|
|
/** */
|
|
var RefIcon$27 = /* @__PURE__ */ import_react.forwardRef(FileTwoTone);
|
|
RefIcon$27.displayName = "FileTwoTone";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/FilterFilled.js
|
|
var FilterFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M349 838c0 17.7 14.2 32 31.8 32h262.4c17.6 0 31.8-14.3 31.8-32V642H349v196zm531.1-684H143.9c-24.5 0-39.8 26.7-27.5 48l221.3 376h348.8l221.3-376c12.1-21.3-3.2-48-27.7-48z" }
|
|
}]
|
|
},
|
|
"name": "filter",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/FilterFilled.js
|
|
function _extends$26() {
|
|
_extends$26 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$26.apply(this, arguments);
|
|
}
|
|
var FilterFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$26({}, props, {
|
|
ref,
|
|
icon: FilterFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$26 = /* @__PURE__ */ import_react.forwardRef(FilterFilled);
|
|
RefIcon$26.displayName = "FilterFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/FolderOpenOutlined.js
|
|
var FolderOpenOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M928 444H820V330.4c0-17.7-14.3-32-32-32H473L355.7 186.2a8.15 8.15 0 00-5.5-2.2H96c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h698c13 0 24.8-7.9 29.7-20l134-332c1.5-3.8 2.3-7.9 2.3-12 0-17.7-14.3-32-32-32zM136 256h188.5l119.6 114.4H748V444H238c-13 0-24.8 7.9-29.7 20L136 643.2V256zm635.3 512H159l103.3-256h612.4L771.3 768z" }
|
|
}]
|
|
},
|
|
"name": "folder-open",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/FolderOpenOutlined.js
|
|
function _extends$25() {
|
|
_extends$25 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$25.apply(this, arguments);
|
|
}
|
|
var FolderOpenOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$25({}, props, {
|
|
ref,
|
|
icon: FolderOpenOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$25 = /* @__PURE__ */ import_react.forwardRef(FolderOpenOutlined);
|
|
RefIcon$25.displayName = "FolderOpenOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/FolderOutlined.js
|
|
var FolderOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M880 298.4H521L403.7 186.2a8.15 8.15 0 00-5.5-2.2H144c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V330.4c0-17.7-14.3-32-32-32zM840 768H184V256h188.5l119.6 114.4H840V768z" }
|
|
}]
|
|
},
|
|
"name": "folder",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/FolderOutlined.js
|
|
function _extends$24() {
|
|
_extends$24 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$24.apply(this, arguments);
|
|
}
|
|
var FolderOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$24({}, props, {
|
|
ref,
|
|
icon: FolderOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$24 = /* @__PURE__ */ import_react.forwardRef(FolderOutlined);
|
|
RefIcon$24.displayName = "FolderOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/HolderOutlined.js
|
|
var HolderOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M300 276.5a56 56 0 1056-97 56 56 0 00-56 97zm0 284a56 56 0 1056-97 56 56 0 00-56 97zM640 228a56 56 0 10112 0 56 56 0 00-112 0zm0 284a56 56 0 10112 0 56 56 0 00-112 0zM300 844.5a56 56 0 1056-97 56 56 0 00-56 97zM640 796a56 56 0 10112 0 56 56 0 00-112 0z" }
|
|
}]
|
|
},
|
|
"name": "holder",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/HolderOutlined.js
|
|
function _extends$23() {
|
|
_extends$23 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$23.apply(this, arguments);
|
|
}
|
|
var HolderOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$23({}, props, {
|
|
ref,
|
|
icon: HolderOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$23 = /* @__PURE__ */ import_react.forwardRef(HolderOutlined);
|
|
RefIcon$23.displayName = "HolderOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/InfoCircleFilled.js
|
|
var InfoCircleFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm32 664c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V456c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272zm-32-344a48.01 48.01 0 010-96 48.01 48.01 0 010 96z" }
|
|
}]
|
|
},
|
|
"name": "info-circle",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/InfoCircleFilled.js
|
|
function _extends$22() {
|
|
_extends$22 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$22.apply(this, arguments);
|
|
}
|
|
var InfoCircleFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$22({}, props, {
|
|
ref,
|
|
icon: InfoCircleFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$22 = /* @__PURE__ */ import_react.forwardRef(InfoCircleFilled);
|
|
RefIcon$22.displayName = "InfoCircleFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/LeftOutlined.js
|
|
var LeftOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M724 218.3V141c0-6.7-7.7-10.4-12.9-6.3L260.3 486.8a31.86 31.86 0 000 50.3l450.8 352.1c5.3 4.1 12.9.4 12.9-6.3v-77.3c0-4.9-2.3-9.6-6.1-12.6l-360-281 360-281.1c3.8-3 6.1-7.7 6.1-12.6z" }
|
|
}]
|
|
},
|
|
"name": "left",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/LeftOutlined.js
|
|
function _extends$21() {
|
|
_extends$21 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$21.apply(this, arguments);
|
|
}
|
|
var LeftOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$21({}, props, {
|
|
ref,
|
|
icon: LeftOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$21 = /* @__PURE__ */ import_react.forwardRef(LeftOutlined);
|
|
RefIcon$21.displayName = "LeftOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/LoadingOutlined.js
|
|
var LoadingOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "0 0 1024 1024",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 00-94.3-139.9 437.71 437.71 0 00-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z" }
|
|
}]
|
|
},
|
|
"name": "loading",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/LoadingOutlined.js
|
|
function _extends$20() {
|
|
_extends$20 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$20.apply(this, arguments);
|
|
}
|
|
var LoadingOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$20({}, props, {
|
|
ref,
|
|
icon: LoadingOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$20 = /* @__PURE__ */ import_react.forwardRef(LoadingOutlined);
|
|
RefIcon$20.displayName = "LoadingOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/MinusOutlined.js
|
|
var MinusOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M872 474H152c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h720c4.4 0 8-3.6 8-8v-60c0-4.4-3.6-8-8-8z" }
|
|
}]
|
|
},
|
|
"name": "minus",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/MinusOutlined.js
|
|
function _extends$19() {
|
|
_extends$19 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$19.apply(this, arguments);
|
|
}
|
|
var MinusOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$19({}, props, {
|
|
ref,
|
|
icon: MinusOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$19 = /* @__PURE__ */ import_react.forwardRef(MinusOutlined);
|
|
RefIcon$19.displayName = "MinusOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/MinusSquareOutlined.js
|
|
var MinusSquareOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M328 544h368c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H328c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8z" }
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": { "d": "M880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32zm-40 728H184V184h656v656z" }
|
|
}]
|
|
},
|
|
"name": "minus-square",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/MinusSquareOutlined.js
|
|
function _extends$18() {
|
|
_extends$18 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$18.apply(this, arguments);
|
|
}
|
|
var MinusSquareOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$18({}, props, {
|
|
ref,
|
|
icon: MinusSquareOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$18 = /* @__PURE__ */ import_react.forwardRef(MinusSquareOutlined);
|
|
RefIcon$18.displayName = "MinusSquareOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/PaperClipOutlined.js
|
|
var PaperClipOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M779.3 196.6c-94.2-94.2-247.6-94.2-341.7 0l-261 260.8c-1.7 1.7-2.6 4-2.6 6.4s.9 4.7 2.6 6.4l36.9 36.9a9 9 0 0012.7 0l261-260.8c32.4-32.4 75.5-50.2 121.3-50.2s88.9 17.8 121.2 50.2c32.4 32.4 50.2 75.5 50.2 121.2 0 45.8-17.8 88.8-50.2 121.2l-266 265.9-43.1 43.1c-40.3 40.3-105.8 40.3-146.1 0-19.5-19.5-30.2-45.4-30.2-73s10.7-53.5 30.2-73l263.9-263.8c6.7-6.6 15.5-10.3 24.9-10.3h.1c9.4 0 18.1 3.7 24.7 10.3 6.7 6.7 10.3 15.5 10.3 24.9 0 9.3-3.7 18.1-10.3 24.7L372.4 653c-1.7 1.7-2.6 4-2.6 6.4s.9 4.7 2.6 6.4l36.9 36.9a9 9 0 0012.7 0l215.6-215.6c19.9-19.9 30.8-46.3 30.8-74.4s-11-54.6-30.8-74.4c-41.1-41.1-107.9-41-149 0L463 364 224.8 602.1A172.22 172.22 0 00174 724.8c0 46.3 18.1 89.8 50.8 122.5 33.9 33.8 78.3 50.7 122.7 50.7 44.4 0 88.8-16.9 122.6-50.7l309.2-309C824.8 492.7 850 432 850 367.5c.1-64.6-25.1-125.3-70.7-170.9z" }
|
|
}]
|
|
},
|
|
"name": "paper-clip",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/PaperClipOutlined.js
|
|
function _extends$17() {
|
|
_extends$17 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$17.apply(this, arguments);
|
|
}
|
|
var PaperClipOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$17({}, props, {
|
|
ref,
|
|
icon: PaperClipOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$17 = /* @__PURE__ */ import_react.forwardRef(PaperClipOutlined);
|
|
RefIcon$17.displayName = "PaperClipOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/PictureTwoTone.js
|
|
var PictureTwoTone$1 = {
|
|
"icon": function render(primaryColor, secondaryColor) {
|
|
return {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [
|
|
{
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M928 160H96c-17.7 0-32 14.3-32 32v640c0 17.7 14.3 32 32 32h832c17.7 0 32-14.3 32-32V192c0-17.7-14.3-32-32-32zm-40 632H136v-39.9l138.5-164.3 150.1 178L658.1 489 888 761.6V792zm0-129.8L664.2 396.8c-3.2-3.8-9-3.8-12.2 0L424.6 666.4l-144-170.7c-3.2-3.8-9-3.8-12.2 0L136 652.7V232h752v430.2z",
|
|
"fill": primaryColor
|
|
}
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M424.6 765.8l-150.1-178L136 752.1V792h752v-30.4L658.1 489z",
|
|
"fill": secondaryColor
|
|
}
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M136 652.7l132.4-157c3.2-3.8 9-3.8 12.2 0l144 170.7L652 396.8c3.2-3.8 9-3.8 12.2 0L888 662.2V232H136v420.7zM304 280a88 88 0 110 176 88 88 0 010-176z",
|
|
"fill": secondaryColor
|
|
}
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M276 368a28 28 0 1056 0 28 28 0 10-56 0z",
|
|
"fill": secondaryColor
|
|
}
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": {
|
|
"d": "M304 456a88 88 0 100-176 88 88 0 000 176zm0-116c15.5 0 28 12.5 28 28s-12.5 28-28 28-28-12.5-28-28 12.5-28 28-28z",
|
|
"fill": primaryColor
|
|
}
|
|
}
|
|
]
|
|
};
|
|
},
|
|
"name": "picture",
|
|
"theme": "twotone"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/PictureTwoTone.js
|
|
function _extends$16() {
|
|
_extends$16 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$16.apply(this, arguments);
|
|
}
|
|
var PictureTwoTone = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$16({}, props, {
|
|
ref,
|
|
icon: PictureTwoTone$1
|
|
}));
|
|
/** */
|
|
var RefIcon$16 = /* @__PURE__ */ import_react.forwardRef(PictureTwoTone);
|
|
RefIcon$16.displayName = "PictureTwoTone";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/PlusOutlined.js
|
|
var PlusOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z" }
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": { "d": "M192 474h672q8 0 8 8v60q0 8-8 8H160q-8 0-8-8v-60q0-8 8-8z" }
|
|
}]
|
|
},
|
|
"name": "plus",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/PlusOutlined.js
|
|
function _extends$15() {
|
|
_extends$15 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$15.apply(this, arguments);
|
|
}
|
|
var PlusOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$15({}, props, {
|
|
ref,
|
|
icon: PlusOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$15 = /* @__PURE__ */ import_react.forwardRef(PlusOutlined);
|
|
RefIcon$15.displayName = "PlusOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/PlusSquareOutlined.js
|
|
var PlusSquareOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M328 544h152v152c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V544h152c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H544V328c0-4.4-3.6-8-8-8h-48c-4.4 0-8 3.6-8 8v152H328c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8z" }
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": { "d": "M880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32zm-40 728H184V184h656v656z" }
|
|
}]
|
|
},
|
|
"name": "plus-square",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/PlusSquareOutlined.js
|
|
function _extends$14() {
|
|
_extends$14 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$14.apply(this, arguments);
|
|
}
|
|
var PlusSquareOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$14({}, props, {
|
|
ref,
|
|
icon: PlusSquareOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$14 = /* @__PURE__ */ import_react.forwardRef(PlusSquareOutlined);
|
|
RefIcon$14.displayName = "PlusSquareOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/QuestionCircleOutlined.js
|
|
var QuestionCircleOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" }
|
|
}, {
|
|
"tag": "path",
|
|
"attrs": { "d": "M623.6 316.7C593.6 290.4 554 276 512 276s-81.6 14.5-111.6 40.7C369.2 344 352 380.7 352 420v7.6c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V420c0-44.1 43.1-80 96-80s96 35.9 96 80c0 31.1-22 59.6-56.1 72.7-21.2 8.1-39.2 22.3-52.1 40.9-13.1 19-19.9 41.8-19.9 64.9V620c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8v-22.7a48.3 48.3 0 0130.9-44.8c59-22.7 97.1-74.7 97.1-132.5.1-39.3-17.1-76-48.3-103.3zM472 732a40 40 0 1080 0 40 40 0 10-80 0z" }
|
|
}]
|
|
},
|
|
"name": "question-circle",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/QuestionCircleOutlined.js
|
|
function _extends$13() {
|
|
_extends$13 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$13.apply(this, arguments);
|
|
}
|
|
var QuestionCircleOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$13({}, props, {
|
|
ref,
|
|
icon: QuestionCircleOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$13 = /* @__PURE__ */ import_react.forwardRef(QuestionCircleOutlined);
|
|
RefIcon$13.displayName = "QuestionCircleOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/ReloadOutlined.js
|
|
var ReloadOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M909.1 209.3l-56.4 44.1C775.8 155.1 656.2 92 521.9 92 290 92 102.3 279.5 102 511.5 101.7 743.7 289.8 932 521.9 932c181.3 0 335.8-115 394.6-276.1 1.5-4.2-.7-8.9-4.9-10.3l-56.7-19.5a8 8 0 00-10.1 4.8c-1.8 5-3.8 10-5.9 14.9-17.3 41-42.1 77.8-73.7 109.4A344.77 344.77 0 01655.9 829c-42.3 17.9-87.4 27-133.8 27-46.5 0-91.5-9.1-133.8-27A341.5 341.5 0 01279 755.2a342.16 342.16 0 01-73.7-109.4c-17.9-42.4-27-87.4-27-133.9s9.1-91.5 27-133.9c17.3-41 42.1-77.8 73.7-109.4 31.6-31.6 68.4-56.4 109.3-73.8 42.3-17.9 87.4-27 133.8-27 46.5 0 91.5 9.1 133.8 27a341.5 341.5 0 01109.3 73.8c9.9 9.9 19.2 20.4 27.8 31.4l-60.2 47a8 8 0 003 14.1l175.6 43c5 1.2 9.9-2.6 9.9-7.7l.8-180.9c-.1-6.6-7.8-10.3-13-6.2z" }
|
|
}]
|
|
},
|
|
"name": "reload",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/ReloadOutlined.js
|
|
function _extends$12() {
|
|
_extends$12 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$12.apply(this, arguments);
|
|
}
|
|
var ReloadOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$12({}, props, {
|
|
ref,
|
|
icon: ReloadOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$12 = /* @__PURE__ */ import_react.forwardRef(ReloadOutlined);
|
|
RefIcon$12.displayName = "ReloadOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/RightOutlined.js
|
|
var RightOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M765.7 486.8L314.9 134.7A7.97 7.97 0 00302 141v77.3c0 4.9 2.3 9.6 6.1 12.6l360 281.1-360 281.1c-3.9 3-6.1 7.7-6.1 12.6V883c0 6.7 7.7 10.4 12.9 6.3l450.8-352.1a31.96 31.96 0 000-50.4z" }
|
|
}]
|
|
},
|
|
"name": "right",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/RightOutlined.js
|
|
function _extends$11() {
|
|
_extends$11 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$11.apply(this, arguments);
|
|
}
|
|
var RightOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$11({}, props, {
|
|
ref,
|
|
icon: RightOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$11 = /* @__PURE__ */ import_react.forwardRef(RightOutlined);
|
|
RefIcon$11.displayName = "RightOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/RotateLeftOutlined.js
|
|
var RotateLeftOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [
|
|
{
|
|
"tag": "defs",
|
|
"attrs": {},
|
|
"children": [{
|
|
"tag": "style",
|
|
"attrs": {}
|
|
}]
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": { "d": "M672 418H144c-17.7 0-32 14.3-32 32v414c0 17.7 14.3 32 32 32h528c17.7 0 32-14.3 32-32V450c0-17.7-14.3-32-32-32zm-44 402H188V494h440v326z" }
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": { "d": "M819.3 328.5c-78.8-100.7-196-153.6-314.6-154.2l-.2-64c0-6.5-7.6-10.1-12.6-6.1l-128 101c-4 3.1-3.9 9.1 0 12.3L492 318.6c5.1 4 12.7.4 12.6-6.1v-63.9c12.9.1 25.9.9 38.8 2.5 42.1 5.2 82.1 18.2 119 38.7 38.1 21.2 71.2 49.7 98.4 84.3 27.1 34.7 46.7 73.7 58.1 115.8a325.95 325.95 0 016.5 140.9h74.9c14.8-103.6-11.3-213-81-302.3z" }
|
|
}
|
|
]
|
|
},
|
|
"name": "rotate-left",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/RotateLeftOutlined.js
|
|
function _extends$10() {
|
|
_extends$10 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$10.apply(this, arguments);
|
|
}
|
|
var RotateLeftOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$10({}, props, {
|
|
ref,
|
|
icon: RotateLeftOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$10 = /* @__PURE__ */ import_react.forwardRef(RotateLeftOutlined);
|
|
RefIcon$10.displayName = "RotateLeftOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/RotateRightOutlined.js
|
|
var RotateRightOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [
|
|
{
|
|
"tag": "defs",
|
|
"attrs": {},
|
|
"children": [{
|
|
"tag": "style",
|
|
"attrs": {}
|
|
}]
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": { "d": "M480.5 251.2c13-1.6 25.9-2.4 38.8-2.5v63.9c0 6.5 7.5 10.1 12.6 6.1L660 217.6c4-3.2 4-9.2 0-12.3l-128-101c-5.1-4-12.6-.4-12.6 6.1l-.2 64c-118.6.5-235.8 53.4-314.6 154.2A399.75 399.75 0 00123.5 631h74.9c-.9-5.3-1.7-10.7-2.4-16.1-5.1-42.1-2.1-84.1 8.9-124.8 11.4-42.2 31-81.1 58.1-115.8 27.2-34.7 60.3-63.2 98.4-84.3 37-20.6 76.9-33.6 119.1-38.8z" }
|
|
},
|
|
{
|
|
"tag": "path",
|
|
"attrs": { "d": "M880 418H352c-17.7 0-32 14.3-32 32v414c0 17.7 14.3 32 32 32h528c17.7 0 32-14.3 32-32V450c0-17.7-14.3-32-32-32zm-44 402H396V494h440v326z" }
|
|
}
|
|
]
|
|
},
|
|
"name": "rotate-right",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/RotateRightOutlined.js
|
|
function _extends$9() {
|
|
_extends$9 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$9.apply(this, arguments);
|
|
}
|
|
var RotateRightOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$9({}, props, {
|
|
ref,
|
|
icon: RotateRightOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$9 = /* @__PURE__ */ import_react.forwardRef(RotateRightOutlined);
|
|
RefIcon$9.displayName = "RotateRightOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/SearchOutlined.js
|
|
var SearchOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M909.6 854.5L649.9 594.8C690.2 542.7 712 479 712 412c0-80.2-31.3-155.4-87.9-212.1-56.6-56.7-132-87.9-212.1-87.9s-155.5 31.3-212.1 87.9C143.2 256.5 112 331.8 112 412c0 80.1 31.3 155.5 87.9 212.1C256.5 680.8 331.8 712 412 712c67 0 130.6-21.8 182.7-62l259.7 259.6a8.2 8.2 0 0011.6 0l43.6-43.5a8.2 8.2 0 000-11.6zM570.4 570.4C528 612.7 471.8 636 412 636s-116-23.3-158.4-65.6C211.3 528 188 471.8 188 412s23.3-116.1 65.6-158.4C296 211.3 352.2 188 412 188s116.1 23.2 158.4 65.6S636 352.2 636 412s-23.3 116.1-65.6 158.4z" }
|
|
}]
|
|
},
|
|
"name": "search",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/SearchOutlined.js
|
|
function _extends$8() {
|
|
_extends$8 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$8.apply(this, arguments);
|
|
}
|
|
var SearchOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$8({}, props, {
|
|
ref,
|
|
icon: SearchOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$8 = /* @__PURE__ */ import_react.forwardRef(SearchOutlined);
|
|
RefIcon$8.displayName = "SearchOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/StarFilled.js
|
|
var StarFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M908.1 353.1l-253.9-36.9L540.7 86.1c-3.1-6.3-8.2-11.4-14.5-14.5-15.8-7.8-35-1.3-42.9 14.5L369.8 316.2l-253.9 36.9c-7 1-13.4 4.3-18.3 9.3a32.05 32.05 0 00.6 45.3l183.7 179.1-43.4 252.9a31.95 31.95 0 0046.4 33.7L512 754l227.1 119.4c6.2 3.3 13.4 4.4 20.3 3.2 17.4-3 29.1-19.5 26.1-36.9l-43.4-252.9 183.7-179.1c5-4.9 8.3-11.3 9.3-18.3 2.7-17.5-9.5-33.7-27-36.3z" }
|
|
}]
|
|
},
|
|
"name": "star",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/StarFilled.js
|
|
function _extends$7() {
|
|
_extends$7 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$7.apply(this, arguments);
|
|
}
|
|
var StarFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$7({}, props, {
|
|
ref,
|
|
icon: StarFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$7 = /* @__PURE__ */ import_react.forwardRef(StarFilled);
|
|
RefIcon$7.displayName = "StarFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/SwapOutlined.js
|
|
var SwapOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M847.9 592H152c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h605.2L612.9 851c-4.1 5.2-.4 13 6.3 13h72.5c4.9 0 9.5-2.2 12.6-6.1l168.8-214.1c16.5-21 1.6-51.8-25.2-51.8zM872 356H266.8l144.3-183c4.1-5.2.4-13-6.3-13h-72.5c-4.9 0-9.5 2.2-12.6 6.1L150.9 380.2c-16.5 21-1.6 51.8 25.1 51.8h696c4.4 0 8-3.6 8-8v-60c0-4.4-3.6-8-8-8z" }
|
|
}]
|
|
},
|
|
"name": "swap",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/SwapOutlined.js
|
|
function _extends$6() {
|
|
_extends$6 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$6.apply(this, arguments);
|
|
}
|
|
var SwapOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$6({}, props, {
|
|
ref,
|
|
icon: SwapOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$6 = /* @__PURE__ */ import_react.forwardRef(SwapOutlined);
|
|
RefIcon$6.displayName = "SwapOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/SwapRightOutlined.js
|
|
var SwapRightOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "0 0 1024 1024",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M873.1 596.2l-164-208A32 32 0 00684 376h-64.8c-6.7 0-10.4 7.7-6.3 13l144.3 183H152c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h695.9c26.8 0 41.7-30.8 25.2-51.8z" }
|
|
}]
|
|
},
|
|
"name": "swap-right",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/SwapRightOutlined.js
|
|
function _extends$5() {
|
|
_extends$5 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$5.apply(this, arguments);
|
|
}
|
|
var SwapRightOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$5({}, props, {
|
|
ref,
|
|
icon: SwapRightOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$5 = /* @__PURE__ */ import_react.forwardRef(SwapRightOutlined);
|
|
RefIcon$5.displayName = "SwapRightOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/UpOutlined.js
|
|
var UpOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z" }
|
|
}]
|
|
},
|
|
"name": "up",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/UpOutlined.js
|
|
function _extends$4() {
|
|
_extends$4 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$4.apply(this, arguments);
|
|
}
|
|
var UpOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$4({}, props, {
|
|
ref,
|
|
icon: UpOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$4 = /* @__PURE__ */ import_react.forwardRef(UpOutlined);
|
|
RefIcon$4.displayName = "UpOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/VerticalAlignTopOutlined.js
|
|
var VerticalAlignTopOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M859.9 168H164.1c-4.5 0-8.1 3.6-8.1 8v60c0 4.4 3.6 8 8.1 8h695.8c4.5 0 8.1-3.6 8.1-8v-60c0-4.4-3.6-8-8.1-8zM518.3 355a8 8 0 00-12.6 0l-112 141.7a7.98 7.98 0 006.3 12.9h73.9V848c0 4.4 3.6 8 8 8h60c4.4 0 8-3.6 8-8V509.7H624c6.7 0 10.4-7.7 6.3-12.9L518.3 355z" }
|
|
}]
|
|
},
|
|
"name": "vertical-align-top",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/VerticalAlignTopOutlined.js
|
|
function _extends$3() {
|
|
_extends$3 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$3.apply(this, arguments);
|
|
}
|
|
var VerticalAlignTopOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$3({}, props, {
|
|
ref,
|
|
icon: VerticalAlignTopOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$3 = /* @__PURE__ */ import_react.forwardRef(VerticalAlignTopOutlined);
|
|
RefIcon$3.displayName = "VerticalAlignTopOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/WarningFilled.js
|
|
var WarningFilled$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M955.7 856l-416-720c-6.2-10.7-16.9-16-27.7-16s-21.6 5.3-27.7 16l-416 720C56 877.4 71.4 904 96 904h832c24.6 0 40-26.6 27.7-48zM480 416c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v184c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V416zm32 352a48.01 48.01 0 010-96 48.01 48.01 0 010 96z" }
|
|
}]
|
|
},
|
|
"name": "warning",
|
|
"theme": "filled"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/WarningFilled.js
|
|
function _extends$2() {
|
|
_extends$2 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$2.apply(this, arguments);
|
|
}
|
|
var WarningFilled = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$2({}, props, {
|
|
ref,
|
|
icon: WarningFilled$1
|
|
}));
|
|
/** */
|
|
var RefIcon$2 = /* @__PURE__ */ import_react.forwardRef(WarningFilled);
|
|
RefIcon$2.displayName = "WarningFilled";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/ZoomInOutlined.js
|
|
var ZoomInOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M637 443H519V309c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v134H325c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h118v134c0 4.4 3.6 8 8 8h60c4.4 0 8-3.6 8-8V519h118c4.4 0 8-3.6 8-8v-60c0-4.4-3.6-8-8-8zm284 424L775 721c122.1-148.9 113.6-369.5-26-509-148-148.1-388.4-148.1-537 0-148.1 148.6-148.1 389 0 537 139.5 139.6 360.1 148.1 509 26l146 146c3.2 2.8 8.3 2.8 11 0l43-43c2.8-2.7 2.8-7.8 0-11zM696 696c-118.8 118.7-311.2 118.7-430 0-118.7-118.8-118.7-311.2 0-430 118.8-118.7 311.2-118.7 430 0 118.7 118.8 118.7 311.2 0 430z" }
|
|
}]
|
|
},
|
|
"name": "zoom-in",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/ZoomInOutlined.js
|
|
function _extends$1() {
|
|
_extends$1 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends$1.apply(this, arguments);
|
|
}
|
|
var ZoomInOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends$1({}, props, {
|
|
ref,
|
|
icon: ZoomInOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon$1 = /* @__PURE__ */ import_react.forwardRef(ZoomInOutlined);
|
|
RefIcon$1.displayName = "ZoomInOutlined";
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons-svg/es/asn/ZoomOutOutlined.js
|
|
var ZoomOutOutlined$1 = {
|
|
"icon": {
|
|
"tag": "svg",
|
|
"attrs": {
|
|
"viewBox": "64 64 896 896",
|
|
"focusable": "false"
|
|
},
|
|
"children": [{
|
|
"tag": "path",
|
|
"attrs": { "d": "M637 443H325c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h312c4.4 0 8-3.6 8-8v-60c0-4.4-3.6-8-8-8zm284 424L775 721c122.1-148.9 113.6-369.5-26-509-148-148.1-388.4-148.1-537 0-148.1 148.6-148.1 389 0 537 139.5 139.6 360.1 148.1 509 26l146 146c3.2 2.8 8.3 2.8 11 0l43-43c2.8-2.7 2.8-7.8 0-11zM696 696c-118.8 118.7-311.2 118.7-430 0-118.7-118.8-118.7-311.2 0-430 118.8-118.7 311.2-118.7 430 0 118.7 118.8 118.7 311.2 0 430z" }
|
|
}]
|
|
},
|
|
"name": "zoom-out",
|
|
"theme": "outlined"
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@ant-design/icons/es/icons/ZoomOutOutlined.js
|
|
function _extends() {
|
|
_extends = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
|
|
}
|
|
return target;
|
|
};
|
|
return _extends.apply(this, arguments);
|
|
}
|
|
var ZoomOutOutlined = (props, ref) => /* @__PURE__ */ import_react.createElement(Icon, _extends({}, props, {
|
|
ref,
|
|
icon: ZoomOutOutlined$1
|
|
}));
|
|
/** */
|
|
var RefIcon = /* @__PURE__ */ import_react.forwardRef(ZoomOutOutlined);
|
|
RefIcon.displayName = "ZoomOutOutlined";
|
|
//#endregion
|
|
//#region node_modules/react-is/cjs/react-is.development.js
|
|
/**
|
|
* @license React
|
|
* react-is.development.js
|
|
*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
var require_react_is_development = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
(function() {
|
|
"use strict";
|
|
var REACT_ELEMENT_TYPE = Symbol.for("react.element");
|
|
var REACT_PORTAL_TYPE = Symbol.for("react.portal");
|
|
var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
|
var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
|
|
var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
|
|
var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
|
|
var REACT_CONTEXT_TYPE = Symbol.for("react.context");
|
|
var REACT_SERVER_CONTEXT_TYPE = Symbol.for("react.server_context");
|
|
var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
|
|
var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
|
|
var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
|
|
var REACT_MEMO_TYPE = Symbol.for("react.memo");
|
|
var REACT_LAZY_TYPE = Symbol.for("react.lazy");
|
|
var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
|
|
var enableScopeAPI = false;
|
|
var enableCacheElement = false;
|
|
var enableTransitionTracing = false;
|
|
var enableLegacyHidden = false;
|
|
var enableDebugTracing = false;
|
|
var REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
|
|
function isValidElementType(type) {
|
|
if (typeof type === "string" || typeof type === "function") return true;
|
|
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) return true;
|
|
if (typeof type === "object" && type !== null) {
|
|
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) return true;
|
|
}
|
|
return false;
|
|
}
|
|
function typeOf(object) {
|
|
if (typeof object === "object" && object !== null) {
|
|
var $$typeof = object.$$typeof;
|
|
switch ($$typeof) {
|
|
case REACT_ELEMENT_TYPE:
|
|
var type = object.type;
|
|
switch (type) {
|
|
case REACT_FRAGMENT_TYPE:
|
|
case REACT_PROFILER_TYPE:
|
|
case REACT_STRICT_MODE_TYPE:
|
|
case REACT_SUSPENSE_TYPE:
|
|
case REACT_SUSPENSE_LIST_TYPE: return type;
|
|
default:
|
|
var $$typeofType = type && type.$$typeof;
|
|
switch ($$typeofType) {
|
|
case REACT_SERVER_CONTEXT_TYPE:
|
|
case REACT_CONTEXT_TYPE:
|
|
case REACT_FORWARD_REF_TYPE:
|
|
case REACT_LAZY_TYPE:
|
|
case REACT_MEMO_TYPE:
|
|
case REACT_PROVIDER_TYPE: return $$typeofType;
|
|
default: return $$typeof;
|
|
}
|
|
}
|
|
case REACT_PORTAL_TYPE: return $$typeof;
|
|
}
|
|
}
|
|
}
|
|
var ContextConsumer = REACT_CONTEXT_TYPE;
|
|
var ContextProvider = REACT_PROVIDER_TYPE;
|
|
var Element = REACT_ELEMENT_TYPE;
|
|
var ForwardRef = REACT_FORWARD_REF_TYPE;
|
|
var Fragment = REACT_FRAGMENT_TYPE;
|
|
var Lazy = REACT_LAZY_TYPE;
|
|
var Memo = REACT_MEMO_TYPE;
|
|
var Portal = REACT_PORTAL_TYPE;
|
|
var Profiler = REACT_PROFILER_TYPE;
|
|
var StrictMode = REACT_STRICT_MODE_TYPE;
|
|
var Suspense = REACT_SUSPENSE_TYPE;
|
|
var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
|
|
var hasWarnedAboutDeprecatedIsAsyncMode = false;
|
|
var hasWarnedAboutDeprecatedIsConcurrentMode = false;
|
|
function isAsyncMode(object) {
|
|
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
|
|
hasWarnedAboutDeprecatedIsAsyncMode = true;
|
|
console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
|
|
}
|
|
return false;
|
|
}
|
|
function isConcurrentMode(object) {
|
|
if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
|
|
hasWarnedAboutDeprecatedIsConcurrentMode = true;
|
|
console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
|
|
}
|
|
return false;
|
|
}
|
|
function isContextConsumer(object) {
|
|
return typeOf(object) === REACT_CONTEXT_TYPE;
|
|
}
|
|
function isContextProvider(object) {
|
|
return typeOf(object) === REACT_PROVIDER_TYPE;
|
|
}
|
|
function isElement(object) {
|
|
return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
|
|
}
|
|
function isForwardRef(object) {
|
|
return typeOf(object) === REACT_FORWARD_REF_TYPE;
|
|
}
|
|
function isFragment(object) {
|
|
return typeOf(object) === REACT_FRAGMENT_TYPE;
|
|
}
|
|
function isLazy(object) {
|
|
return typeOf(object) === REACT_LAZY_TYPE;
|
|
}
|
|
function isMemo(object) {
|
|
return typeOf(object) === REACT_MEMO_TYPE;
|
|
}
|
|
function isPortal(object) {
|
|
return typeOf(object) === REACT_PORTAL_TYPE;
|
|
}
|
|
function isProfiler(object) {
|
|
return typeOf(object) === REACT_PROFILER_TYPE;
|
|
}
|
|
function isStrictMode(object) {
|
|
return typeOf(object) === REACT_STRICT_MODE_TYPE;
|
|
}
|
|
function isSuspense(object) {
|
|
return typeOf(object) === REACT_SUSPENSE_TYPE;
|
|
}
|
|
function isSuspenseList(object) {
|
|
return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
|
|
}
|
|
exports.ContextConsumer = ContextConsumer;
|
|
exports.ContextProvider = ContextProvider;
|
|
exports.Element = Element;
|
|
exports.ForwardRef = ForwardRef;
|
|
exports.Fragment = Fragment;
|
|
exports.Lazy = Lazy;
|
|
exports.Memo = Memo;
|
|
exports.Portal = Portal;
|
|
exports.Profiler = Profiler;
|
|
exports.StrictMode = StrictMode;
|
|
exports.Suspense = Suspense;
|
|
exports.SuspenseList = SuspenseList;
|
|
exports.isAsyncMode = isAsyncMode;
|
|
exports.isConcurrentMode = isConcurrentMode;
|
|
exports.isContextConsumer = isContextConsumer;
|
|
exports.isContextProvider = isContextProvider;
|
|
exports.isElement = isElement;
|
|
exports.isForwardRef = isForwardRef;
|
|
exports.isFragment = isFragment;
|
|
exports.isLazy = isLazy;
|
|
exports.isMemo = isMemo;
|
|
exports.isPortal = isPortal;
|
|
exports.isProfiler = isProfiler;
|
|
exports.isStrictMode = isStrictMode;
|
|
exports.isSuspense = isSuspense;
|
|
exports.isSuspenseList = isSuspenseList;
|
|
exports.isValidElementType = isValidElementType;
|
|
exports.typeOf = typeOf;
|
|
})();
|
|
}));
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/hooks/useMemo.js
|
|
var import_react_is = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
module.exports = require_react_is_development();
|
|
})))();
|
|
function useMemo(getValue, condition, shouldUpdate) {
|
|
const cacheRef = import_react.useRef({});
|
|
if (!("value" in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
|
|
cacheRef.current.value = getValue();
|
|
cacheRef.current.condition = condition;
|
|
}
|
|
return cacheRef.current.value;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/React/isFragment.js
|
|
var REACT_ELEMENT_TYPE_18 = Symbol.for("react.element");
|
|
var REACT_ELEMENT_TYPE_19 = Symbol.for("react.transitional.element");
|
|
var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
|
/**
|
|
* Compatible with React 18 or 19 to check if node is a Fragment.
|
|
*/
|
|
function isFragment(object) {
|
|
return object && typeof object === "object" && (object.$$typeof === REACT_ELEMENT_TYPE_18 || object.$$typeof === REACT_ELEMENT_TYPE_19) && object.type === REACT_FRAGMENT_TYPE;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@rc-component/util/es/ref.js
|
|
var ReactMajorVersion = Number(import_react.version.split(".")[0]);
|
|
var fillRef = (ref, node) => {
|
|
if (typeof ref === "function") ref(node);
|
|
else if (typeof ref === "object" && ref && "current" in ref) ref.current = node;
|
|
};
|
|
/**
|
|
* Merge refs into one ref function to support ref passing.
|
|
*/
|
|
var composeRef = (...refs) => {
|
|
const refList = refs.filter(Boolean);
|
|
if (refList.length <= 1) return refList[0];
|
|
return (node) => {
|
|
refs.forEach((ref) => {
|
|
fillRef(ref, node);
|
|
});
|
|
};
|
|
};
|
|
var useComposeRef = (...refs) => {
|
|
return useMemo(() => composeRef(...refs), refs, (prev, next) => prev.length !== next.length || prev.every((ref, i) => ref !== next[i]));
|
|
};
|
|
var supportRef = (nodeOrComponent) => {
|
|
if (!nodeOrComponent) return false;
|
|
if (isReactElement(nodeOrComponent) && ReactMajorVersion >= 19) return true;
|
|
const type = (0, import_react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
|
|
if (typeof type === "function" && !type.prototype?.render && type.$$typeof !== import_react_is.ForwardRef) return false;
|
|
if (typeof nodeOrComponent === "function" && !nodeOrComponent.prototype?.render && nodeOrComponent.$$typeof !== import_react_is.ForwardRef) return false;
|
|
return true;
|
|
};
|
|
function isReactElement(node) {
|
|
return /* @__PURE__ */ (0, import_react.isValidElement)(node) && !isFragment(node);
|
|
}
|
|
var supportNodeRef = (node) => {
|
|
return isReactElement(node) && supportRef(node);
|
|
};
|
|
/**
|
|
* In React 19. `ref` is not a property from node.
|
|
* But a property from `props.ref`.
|
|
* To check if `props.ref` exist or fallback to `ref`.
|
|
*/
|
|
var getNodeRef = (node) => {
|
|
if (node && isReactElement(node)) {
|
|
const ele = node;
|
|
return ele.props.propertyIsEnumerable("ref") ? ele.props.ref : ele.ref;
|
|
}
|
|
return null;
|
|
};
|
|
//#endregion
|
|
export { RefIcon$44 as $, RefIcon$21 as A, RefIcon$31 as B, RefIcon$14 as C, presetPalettes as Ct, RefIcon$18 as D, clsx as Dt, RefIcon$17 as E, FastColor as Et, RefIcon$26 as F, RefIcon$36 as G, RefIcon$33 as H, RefIcon$27 as I, RefIcon$39 as J, RefIcon$37 as K, RefIcon$28 as L, RefIcon$23 as M, RefIcon$24 as N, RefIcon$19 as O, IconContext as Ot, RefIcon$25 as P, RefIcon$43 as Q, RefIcon$29 as R, RefIcon$13 as S, gold as St, RefIcon$16 as T, generate$1 as Tt, RefIcon$34 as U, RefIcon$32 as V, RefIcon$35 as W, RefIcon$41 as X, RefIcon$40 as Y, RefIcon$42 as Z, RefIcon$8 as _, removeCSS as _t, supportRef as a, RefIcon$50 as at, RefIcon$11 as b, canUseDom as bt, useMemo as c, getTwoToneColor as ct, RefIcon$2 as d, useInsertStyles as dt, RefIcon$45 as et, RefIcon$3 as f, warning as ft, RefIcon$7 as g, getShadowRoot as gt, RefIcon$6 as h, warningOnce as ht, supportNodeRef as i, RefIcon$49 as it, RefIcon$22 as j, RefIcon$20 as k, RefIcon as l, setTwoToneColor as lt, RefIcon$5 as m, warning$1 as mt, fillRef as n, RefIcon$47 as nt, useComposeRef as o, RefIcon$51 as ot, RefIcon$4 as p, noteOnce as pt, RefIcon$38 as q, getNodeRef as r, RefIcon$48 as rt, isFragment as s, Icon as st, composeRef as t, RefIcon$46 as tt, RefIcon$1 as u, svgBaseProps as ut, RefIcon$9 as v, updateCSS as vt, RefIcon$15 as w, presetPrimaryColors as wt, RefIcon$12 as x, blue as xt, RefIcon$10 as y, contains as yt, RefIcon$30 as z };
|
|
|
|
//# sourceMappingURL=ref-CC_C1lUG.js.map
|