2353 lines
83 KiB
JavaScript
2353 lines
83 KiB
JavaScript
import {
|
|
_assertThisInitialized,
|
|
_setPrototypeOf
|
|
} from "./chunk-FSGBSGQ2.js";
|
|
import {
|
|
_arrayLikeToArray,
|
|
_objectSpread2,
|
|
_objectWithoutProperties,
|
|
_slicedToArray,
|
|
_unsupportedIterableToArray,
|
|
canUseDom,
|
|
removeCSS,
|
|
updateCSS,
|
|
useMemo,
|
|
warning,
|
|
warning_default
|
|
} from "./chunk-KBMHTFOP.js";
|
|
import {
|
|
_extends
|
|
} from "./chunk-4NTHFIFD.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-7ZNOTH45.js";
|
|
import {
|
|
_defineProperty,
|
|
_typeof,
|
|
init_defineProperty,
|
|
init_toPropertyKey,
|
|
init_typeof,
|
|
toPropertyKey
|
|
} from "./chunk-R546NDVX.js";
|
|
import {
|
|
__toESM
|
|
} from "./chunk-V4OQ3NZ2.js";
|
|
|
|
// node_modules/@ant-design/cssinjs/es/extractStyle.js
|
|
init_defineProperty();
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
|
|
function _arrayWithoutHoles(r) {
|
|
if (Array.isArray(r)) return _arrayLikeToArray(r);
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/iterableToArray.js
|
|
function _iterableToArray(r) {
|
|
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
|
|
function _nonIterableSpread() {
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
|
|
function _toConsumableArray(r) {
|
|
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
|
|
}
|
|
|
|
// node_modules/@emotion/hash/dist/hash.browser.esm.js
|
|
function murmur2(str) {
|
|
var h = 0;
|
|
var k, i = 0, len = str.length;
|
|
for (; len >= 4; ++i, len -= 4) {
|
|
k = str.charCodeAt(i) & 255 | (str.charCodeAt(++i) & 255) << 8 | (str.charCodeAt(++i) & 255) << 16 | (str.charCodeAt(++i) & 255) << 24;
|
|
k = /* Math.imul(k, m): */
|
|
(k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16);
|
|
k ^= /* k >>> r: */
|
|
k >>> 24;
|
|
h = /* Math.imul(k, m): */
|
|
(k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16) ^ /* Math.imul(h, m): */
|
|
(h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
|
|
}
|
|
switch (len) {
|
|
case 3:
|
|
h ^= (str.charCodeAt(i + 2) & 255) << 16;
|
|
case 2:
|
|
h ^= (str.charCodeAt(i + 1) & 255) << 8;
|
|
case 1:
|
|
h ^= str.charCodeAt(i) & 255;
|
|
h = /* Math.imul(h, m): */
|
|
(h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
|
|
}
|
|
h ^= h >>> 13;
|
|
h = /* Math.imul(h, m): */
|
|
(h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
|
|
return ((h ^ h >>> 15) >>> 0).toString(36);
|
|
}
|
|
var hash_browser_esm_default = murmur2;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useCacheToken.js
|
|
var import_react = __toESM(require_react());
|
|
|
|
// node_modules/rc-util/es/isEqual.js
|
|
init_typeof();
|
|
function isEqual(obj1, obj2) {
|
|
var shallow = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
|
|
var refSet = /* @__PURE__ */ new Set();
|
|
function deepEqual(a, b) {
|
|
var level = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
|
|
var circular = refSet.has(a);
|
|
warning_default(!circular, "Warning: There may be circular references");
|
|
if (circular) {
|
|
return false;
|
|
}
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (shallow && level > 1) {
|
|
return false;
|
|
}
|
|
refSet.add(a);
|
|
var newLevel = level + 1;
|
|
if (Array.isArray(a)) {
|
|
if (!Array.isArray(b) || a.length !== b.length) {
|
|
return false;
|
|
}
|
|
for (var i = 0; i < a.length; i++) {
|
|
if (!deepEqual(a[i], b[i], newLevel)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (a && b && _typeof(a) === "object" && _typeof(b) === "object") {
|
|
var keys = Object.keys(a);
|
|
if (keys.length !== Object.keys(b).length) {
|
|
return false;
|
|
}
|
|
return keys.every(function(key) {
|
|
return deepEqual(a[key], b[key], newLevel);
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
return deepEqual(obj1, obj2);
|
|
}
|
|
var isEqual_default = isEqual;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/StyleContext.js
|
|
var React = __toESM(require_react());
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/classCallCheck.js
|
|
function _classCallCheck(a, n) {
|
|
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
init_toPropertyKey();
|
|
function _defineProperties(e, r) {
|
|
for (var t = 0; t < r.length; t++) {
|
|
var o = r[t];
|
|
o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
|
|
}
|
|
}
|
|
function _createClass(e, r, t) {
|
|
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
|
|
writable: false
|
|
}), e;
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/Cache.js
|
|
init_defineProperty();
|
|
var SPLIT = "%";
|
|
function pathKey(keys) {
|
|
return keys.join(SPLIT);
|
|
}
|
|
var Entity = (function() {
|
|
function Entity2(instanceId) {
|
|
_classCallCheck(this, Entity2);
|
|
_defineProperty(this, "instanceId", void 0);
|
|
_defineProperty(this, "cache", /* @__PURE__ */ new Map());
|
|
_defineProperty(this, "extracted", /* @__PURE__ */ new Set());
|
|
this.instanceId = instanceId;
|
|
}
|
|
_createClass(Entity2, [{
|
|
key: "get",
|
|
value: function get(keys) {
|
|
return this.opGet(pathKey(keys));
|
|
}
|
|
/** A fast get cache with `get` concat. */
|
|
}, {
|
|
key: "opGet",
|
|
value: function opGet(keyPathStr) {
|
|
return this.cache.get(keyPathStr) || null;
|
|
}
|
|
}, {
|
|
key: "update",
|
|
value: function update(keys, valueFn) {
|
|
return this.opUpdate(pathKey(keys), valueFn);
|
|
}
|
|
/** A fast get cache with `get` concat. */
|
|
}, {
|
|
key: "opUpdate",
|
|
value: function opUpdate(keyPathStr, valueFn) {
|
|
var prevValue = this.cache.get(keyPathStr);
|
|
var nextValue = valueFn(prevValue);
|
|
if (nextValue === null) {
|
|
this.cache.delete(keyPathStr);
|
|
} else {
|
|
this.cache.set(keyPathStr, nextValue);
|
|
}
|
|
}
|
|
}]);
|
|
return Entity2;
|
|
})();
|
|
var Cache_default = Entity;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/StyleContext.js
|
|
var _excluded = ["children"];
|
|
var ATTR_TOKEN = "data-token-hash";
|
|
var ATTR_MARK = "data-css-hash";
|
|
var ATTR_CACHE_PATH = "data-cache-path";
|
|
var CSS_IN_JS_INSTANCE = "__cssinjs_instance__";
|
|
function createCache() {
|
|
var cssinjsInstanceId = Math.random().toString(12).slice(2);
|
|
if (typeof document !== "undefined" && document.head && document.body) {
|
|
var styles = document.body.querySelectorAll("style[".concat(ATTR_MARK, "]")) || [];
|
|
var firstChild = document.head.firstChild;
|
|
Array.from(styles).forEach(function(style) {
|
|
style[CSS_IN_JS_INSTANCE] = style[CSS_IN_JS_INSTANCE] || cssinjsInstanceId;
|
|
if (style[CSS_IN_JS_INSTANCE] === cssinjsInstanceId) {
|
|
document.head.insertBefore(style, firstChild);
|
|
}
|
|
});
|
|
var styleHash = {};
|
|
Array.from(document.querySelectorAll("style[".concat(ATTR_MARK, "]"))).forEach(function(style) {
|
|
var hash2 = style.getAttribute(ATTR_MARK);
|
|
if (styleHash[hash2]) {
|
|
if (style[CSS_IN_JS_INSTANCE] === cssinjsInstanceId) {
|
|
var _style$parentNode;
|
|
(_style$parentNode = style.parentNode) === null || _style$parentNode === void 0 || _style$parentNode.removeChild(style);
|
|
}
|
|
} else {
|
|
styleHash[hash2] = true;
|
|
}
|
|
});
|
|
}
|
|
return new Cache_default(cssinjsInstanceId);
|
|
}
|
|
var StyleContext = React.createContext({
|
|
hashPriority: "low",
|
|
cache: createCache(),
|
|
defaultCache: true
|
|
});
|
|
var StyleProvider = function StyleProvider2(props) {
|
|
var children = props.children, restProps = _objectWithoutProperties(props, _excluded);
|
|
var parentContext = React.useContext(StyleContext);
|
|
var context = useMemo(function() {
|
|
var mergedContext = _objectSpread2({}, parentContext);
|
|
Object.keys(restProps).forEach(function(key) {
|
|
var value = restProps[key];
|
|
if (restProps[key] !== void 0) {
|
|
mergedContext[key] = value;
|
|
}
|
|
});
|
|
var cache = restProps.cache;
|
|
mergedContext.cache = mergedContext.cache || createCache();
|
|
mergedContext.defaultCache = !cache && parentContext.defaultCache;
|
|
return mergedContext;
|
|
}, [parentContext, restProps], function(prev2, next2) {
|
|
return !isEqual_default(prev2[0], next2[0], true) || !isEqual_default(prev2[1], next2[1], true);
|
|
});
|
|
return React.createElement(StyleContext.Provider, {
|
|
value: context
|
|
}, children);
|
|
};
|
|
var StyleContext_default = StyleContext;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/util/index.js
|
|
init_defineProperty();
|
|
init_typeof();
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/calc/CSSCalculator.js
|
|
init_typeof();
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/inherits.js
|
|
function _inherits(t, e) {
|
|
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
|
|
t.prototype = Object.create(e && e.prototype, {
|
|
constructor: {
|
|
value: t,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
}), Object.defineProperty(t, "prototype", {
|
|
writable: false
|
|
}), e && _setPrototypeOf(t, e);
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
|
|
function _getPrototypeOf(t) {
|
|
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
|
|
return t2.__proto__ || Object.getPrototypeOf(t2);
|
|
}, _getPrototypeOf(t);
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js
|
|
function _isNativeReflectConstruct() {
|
|
try {
|
|
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
|
|
}));
|
|
} catch (t2) {
|
|
}
|
|
return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
|
|
return !!t;
|
|
})();
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
|
|
init_typeof();
|
|
function _possibleConstructorReturn(t, e) {
|
|
if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
|
|
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
|
|
return _assertThisInitialized(t);
|
|
}
|
|
|
|
// node_modules/@babel/runtime/helpers/esm/createSuper.js
|
|
function _createSuper(t) {
|
|
var r = _isNativeReflectConstruct();
|
|
return function() {
|
|
var e, o = _getPrototypeOf(t);
|
|
if (r) {
|
|
var s = _getPrototypeOf(this).constructor;
|
|
e = Reflect.construct(o, arguments, s);
|
|
} else e = o.apply(this, arguments);
|
|
return _possibleConstructorReturn(this, e);
|
|
};
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/calc/CSSCalculator.js
|
|
init_defineProperty();
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/calc/calculator.js
|
|
var AbstractCalculator = _createClass(function AbstractCalculator2() {
|
|
_classCallCheck(this, AbstractCalculator2);
|
|
});
|
|
var calculator_default = AbstractCalculator;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/calc/CSSCalculator.js
|
|
var CALC_UNIT = "CALC_UNIT";
|
|
var regexp = new RegExp(CALC_UNIT, "g");
|
|
function unit(value) {
|
|
if (typeof value === "number") {
|
|
return "".concat(value).concat(CALC_UNIT);
|
|
}
|
|
return value;
|
|
}
|
|
var CSSCalculator = (function(_AbstractCalculator) {
|
|
_inherits(CSSCalculator2, _AbstractCalculator);
|
|
var _super = _createSuper(CSSCalculator2);
|
|
function CSSCalculator2(num, unitlessCssVar) {
|
|
var _this;
|
|
_classCallCheck(this, CSSCalculator2);
|
|
_this = _super.call(this);
|
|
_defineProperty(_assertThisInitialized(_this), "result", "");
|
|
_defineProperty(_assertThisInitialized(_this), "unitlessCssVar", void 0);
|
|
_defineProperty(_assertThisInitialized(_this), "lowPriority", void 0);
|
|
var numType = _typeof(num);
|
|
_this.unitlessCssVar = unitlessCssVar;
|
|
if (num instanceof CSSCalculator2) {
|
|
_this.result = "(".concat(num.result, ")");
|
|
} else if (numType === "number") {
|
|
_this.result = unit(num);
|
|
} else if (numType === "string") {
|
|
_this.result = num;
|
|
}
|
|
return _this;
|
|
}
|
|
_createClass(CSSCalculator2, [{
|
|
key: "add",
|
|
value: function add(num) {
|
|
if (num instanceof CSSCalculator2) {
|
|
this.result = "".concat(this.result, " + ").concat(num.getResult());
|
|
} else if (typeof num === "number" || typeof num === "string") {
|
|
this.result = "".concat(this.result, " + ").concat(unit(num));
|
|
}
|
|
this.lowPriority = true;
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "sub",
|
|
value: function sub(num) {
|
|
if (num instanceof CSSCalculator2) {
|
|
this.result = "".concat(this.result, " - ").concat(num.getResult());
|
|
} else if (typeof num === "number" || typeof num === "string") {
|
|
this.result = "".concat(this.result, " - ").concat(unit(num));
|
|
}
|
|
this.lowPriority = true;
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "mul",
|
|
value: function mul(num) {
|
|
if (this.lowPriority) {
|
|
this.result = "(".concat(this.result, ")");
|
|
}
|
|
if (num instanceof CSSCalculator2) {
|
|
this.result = "".concat(this.result, " * ").concat(num.getResult(true));
|
|
} else if (typeof num === "number" || typeof num === "string") {
|
|
this.result = "".concat(this.result, " * ").concat(num);
|
|
}
|
|
this.lowPriority = false;
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "div",
|
|
value: function div(num) {
|
|
if (this.lowPriority) {
|
|
this.result = "(".concat(this.result, ")");
|
|
}
|
|
if (num instanceof CSSCalculator2) {
|
|
this.result = "".concat(this.result, " / ").concat(num.getResult(true));
|
|
} else if (typeof num === "number" || typeof num === "string") {
|
|
this.result = "".concat(this.result, " / ").concat(num);
|
|
}
|
|
this.lowPriority = false;
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "getResult",
|
|
value: function getResult(force) {
|
|
return this.lowPriority || force ? "(".concat(this.result, ")") : this.result;
|
|
}
|
|
}, {
|
|
key: "equal",
|
|
value: function equal(options) {
|
|
var _this2 = this;
|
|
var _ref = options || {}, cssUnit = _ref.unit;
|
|
var mergedUnit = true;
|
|
if (typeof cssUnit === "boolean") {
|
|
mergedUnit = cssUnit;
|
|
} else if (Array.from(this.unitlessCssVar).some(function(cssVar) {
|
|
return _this2.result.includes(cssVar);
|
|
})) {
|
|
mergedUnit = false;
|
|
}
|
|
this.result = this.result.replace(regexp, mergedUnit ? "px" : "");
|
|
if (typeof this.lowPriority !== "undefined") {
|
|
return "calc(".concat(this.result, ")");
|
|
}
|
|
return this.result;
|
|
}
|
|
}]);
|
|
return CSSCalculator2;
|
|
})(calculator_default);
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/calc/NumCalculator.js
|
|
init_defineProperty();
|
|
var NumCalculator = (function(_AbstractCalculator) {
|
|
_inherits(NumCalculator2, _AbstractCalculator);
|
|
var _super = _createSuper(NumCalculator2);
|
|
function NumCalculator2(num) {
|
|
var _this;
|
|
_classCallCheck(this, NumCalculator2);
|
|
_this = _super.call(this);
|
|
_defineProperty(_assertThisInitialized(_this), "result", 0);
|
|
if (num instanceof NumCalculator2) {
|
|
_this.result = num.result;
|
|
} else if (typeof num === "number") {
|
|
_this.result = num;
|
|
}
|
|
return _this;
|
|
}
|
|
_createClass(NumCalculator2, [{
|
|
key: "add",
|
|
value: function add(num) {
|
|
if (num instanceof NumCalculator2) {
|
|
this.result += num.result;
|
|
} else if (typeof num === "number") {
|
|
this.result += num;
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "sub",
|
|
value: function sub(num) {
|
|
if (num instanceof NumCalculator2) {
|
|
this.result -= num.result;
|
|
} else if (typeof num === "number") {
|
|
this.result -= num;
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "mul",
|
|
value: function mul(num) {
|
|
if (num instanceof NumCalculator2) {
|
|
this.result *= num.result;
|
|
} else if (typeof num === "number") {
|
|
this.result *= num;
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "div",
|
|
value: function div(num) {
|
|
if (num instanceof NumCalculator2) {
|
|
this.result /= num.result;
|
|
} else if (typeof num === "number") {
|
|
this.result /= num;
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "equal",
|
|
value: function equal() {
|
|
return this.result;
|
|
}
|
|
}]);
|
|
return NumCalculator2;
|
|
})(calculator_default);
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/calc/index.js
|
|
var genCalc = function genCalc2(type, unitlessCssVar) {
|
|
var Calculator = type === "css" ? CSSCalculator : NumCalculator;
|
|
return function(num) {
|
|
return new Calculator(num, unitlessCssVar);
|
|
};
|
|
};
|
|
var calc_default = genCalc;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/ThemeCache.js
|
|
init_defineProperty();
|
|
function sameDerivativeOption(left, right) {
|
|
if (left.length !== right.length) {
|
|
return false;
|
|
}
|
|
for (var i = 0; i < left.length; i++) {
|
|
if (left[i] !== right[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var ThemeCache = (function() {
|
|
function ThemeCache2() {
|
|
_classCallCheck(this, ThemeCache2);
|
|
_defineProperty(this, "cache", void 0);
|
|
_defineProperty(this, "keys", void 0);
|
|
_defineProperty(this, "cacheCallTimes", void 0);
|
|
this.cache = /* @__PURE__ */ new Map();
|
|
this.keys = [];
|
|
this.cacheCallTimes = 0;
|
|
}
|
|
_createClass(ThemeCache2, [{
|
|
key: "size",
|
|
value: function size() {
|
|
return this.keys.length;
|
|
}
|
|
}, {
|
|
key: "internalGet",
|
|
value: function internalGet(derivativeOption) {
|
|
var _cache2, _cache3;
|
|
var updateCallTimes = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
|
|
var cache = {
|
|
map: this.cache
|
|
};
|
|
derivativeOption.forEach(function(derivative) {
|
|
if (!cache) {
|
|
cache = void 0;
|
|
} else {
|
|
var _cache;
|
|
cache = (_cache = cache) === null || _cache === void 0 || (_cache = _cache.map) === null || _cache === void 0 ? void 0 : _cache.get(derivative);
|
|
}
|
|
});
|
|
if ((_cache2 = cache) !== null && _cache2 !== void 0 && _cache2.value && updateCallTimes) {
|
|
cache.value[1] = this.cacheCallTimes++;
|
|
}
|
|
return (_cache3 = cache) === null || _cache3 === void 0 ? void 0 : _cache3.value;
|
|
}
|
|
}, {
|
|
key: "get",
|
|
value: function get(derivativeOption) {
|
|
var _this$internalGet;
|
|
return (_this$internalGet = this.internalGet(derivativeOption, true)) === null || _this$internalGet === void 0 ? void 0 : _this$internalGet[0];
|
|
}
|
|
}, {
|
|
key: "has",
|
|
value: function has(derivativeOption) {
|
|
return !!this.internalGet(derivativeOption);
|
|
}
|
|
}, {
|
|
key: "set",
|
|
value: function set(derivativeOption, value) {
|
|
var _this = this;
|
|
if (!this.has(derivativeOption)) {
|
|
if (this.size() + 1 > ThemeCache2.MAX_CACHE_SIZE + ThemeCache2.MAX_CACHE_OFFSET) {
|
|
var _this$keys$reduce = this.keys.reduce(function(result, key) {
|
|
var _result = _slicedToArray(result, 2), callTimes = _result[1];
|
|
if (_this.internalGet(key)[1] < callTimes) {
|
|
return [key, _this.internalGet(key)[1]];
|
|
}
|
|
return result;
|
|
}, [this.keys[0], this.cacheCallTimes]), _this$keys$reduce2 = _slicedToArray(_this$keys$reduce, 1), targetKey = _this$keys$reduce2[0];
|
|
this.delete(targetKey);
|
|
}
|
|
this.keys.push(derivativeOption);
|
|
}
|
|
var cache = this.cache;
|
|
derivativeOption.forEach(function(derivative, index) {
|
|
if (index === derivativeOption.length - 1) {
|
|
cache.set(derivative, {
|
|
value: [value, _this.cacheCallTimes++]
|
|
});
|
|
} else {
|
|
var cacheValue = cache.get(derivative);
|
|
if (!cacheValue) {
|
|
cache.set(derivative, {
|
|
map: /* @__PURE__ */ new Map()
|
|
});
|
|
} else if (!cacheValue.map) {
|
|
cacheValue.map = /* @__PURE__ */ new Map();
|
|
}
|
|
cache = cache.get(derivative).map;
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "deleteByPath",
|
|
value: function deleteByPath(currentCache, derivatives) {
|
|
var cache = currentCache.get(derivatives[0]);
|
|
if (derivatives.length === 1) {
|
|
var _cache$value;
|
|
if (!cache.map) {
|
|
currentCache.delete(derivatives[0]);
|
|
} else {
|
|
currentCache.set(derivatives[0], {
|
|
map: cache.map
|
|
});
|
|
}
|
|
return (_cache$value = cache.value) === null || _cache$value === void 0 ? void 0 : _cache$value[0];
|
|
}
|
|
var result = this.deleteByPath(cache.map, derivatives.slice(1));
|
|
if ((!cache.map || cache.map.size === 0) && !cache.value) {
|
|
currentCache.delete(derivatives[0]);
|
|
}
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "delete",
|
|
value: function _delete(derivativeOption) {
|
|
if (this.has(derivativeOption)) {
|
|
this.keys = this.keys.filter(function(item) {
|
|
return !sameDerivativeOption(item, derivativeOption);
|
|
});
|
|
return this.deleteByPath(this.cache, derivativeOption);
|
|
}
|
|
return void 0;
|
|
}
|
|
}]);
|
|
return ThemeCache2;
|
|
})();
|
|
_defineProperty(ThemeCache, "MAX_CACHE_SIZE", 20);
|
|
_defineProperty(ThemeCache, "MAX_CACHE_OFFSET", 5);
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/Theme.js
|
|
init_defineProperty();
|
|
var uuid = 0;
|
|
var Theme = (function() {
|
|
function Theme2(derivatives) {
|
|
_classCallCheck(this, Theme2);
|
|
_defineProperty(this, "derivatives", void 0);
|
|
_defineProperty(this, "id", void 0);
|
|
this.derivatives = Array.isArray(derivatives) ? derivatives : [derivatives];
|
|
this.id = uuid;
|
|
if (derivatives.length === 0) {
|
|
warning(derivatives.length > 0, "[Ant Design CSS-in-JS] Theme should have at least one derivative function.");
|
|
}
|
|
uuid += 1;
|
|
}
|
|
_createClass(Theme2, [{
|
|
key: "getDerivativeToken",
|
|
value: function getDerivativeToken(token2) {
|
|
return this.derivatives.reduce(function(result, derivative) {
|
|
return derivative(token2, result);
|
|
}, void 0);
|
|
}
|
|
}]);
|
|
return Theme2;
|
|
})();
|
|
|
|
// node_modules/@ant-design/cssinjs/es/theme/createTheme.js
|
|
var cacheThemes = new ThemeCache();
|
|
function createTheme(derivatives) {
|
|
var derivativeArr = Array.isArray(derivatives) ? derivatives : [derivatives];
|
|
if (!cacheThemes.has(derivativeArr)) {
|
|
cacheThemes.set(derivativeArr, new Theme(derivativeArr));
|
|
}
|
|
return cacheThemes.get(derivativeArr);
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/util/index.js
|
|
var resultCache = /* @__PURE__ */ new WeakMap();
|
|
var RESULT_VALUE = {};
|
|
function memoResult(callback, deps) {
|
|
var current = resultCache;
|
|
for (var i = 0; i < deps.length; i += 1) {
|
|
var dep = deps[i];
|
|
if (!current.has(dep)) {
|
|
current.set(dep, /* @__PURE__ */ new WeakMap());
|
|
}
|
|
current = current.get(dep);
|
|
}
|
|
if (!current.has(RESULT_VALUE)) {
|
|
current.set(RESULT_VALUE, callback());
|
|
}
|
|
return current.get(RESULT_VALUE);
|
|
}
|
|
var flattenTokenCache = /* @__PURE__ */ new WeakMap();
|
|
function flattenToken(token2) {
|
|
var str = flattenTokenCache.get(token2) || "";
|
|
if (!str) {
|
|
Object.keys(token2).forEach(function(key) {
|
|
var value = token2[key];
|
|
str += key;
|
|
if (value instanceof Theme) {
|
|
str += value.id;
|
|
} else if (value && _typeof(value) === "object") {
|
|
str += flattenToken(value);
|
|
} else {
|
|
str += value;
|
|
}
|
|
});
|
|
str = hash_browser_esm_default(str);
|
|
flattenTokenCache.set(token2, str);
|
|
}
|
|
return str;
|
|
}
|
|
function token2key(token2, salt) {
|
|
return hash_browser_esm_default("".concat(salt, "_").concat(flattenToken(token2)));
|
|
}
|
|
var randomSelectorKey = "random-".concat(Date.now(), "-").concat(Math.random()).replace(/\./g, "");
|
|
var checkContent = "_bAmBoO_";
|
|
function supportSelector(styleStr, handleElement, supportCheck) {
|
|
if (canUseDom()) {
|
|
var _getComputedStyle$con, _ele$parentNode;
|
|
updateCSS(styleStr, randomSelectorKey);
|
|
var _ele = document.createElement("div");
|
|
_ele.style.position = "fixed";
|
|
_ele.style.left = "0";
|
|
_ele.style.top = "0";
|
|
handleElement === null || handleElement === void 0 || handleElement(_ele);
|
|
document.body.appendChild(_ele);
|
|
if (true) {
|
|
_ele.innerHTML = "Test";
|
|
_ele.style.zIndex = "9999999";
|
|
}
|
|
var support = supportCheck ? supportCheck(_ele) : (_getComputedStyle$con = getComputedStyle(_ele).content) === null || _getComputedStyle$con === void 0 ? void 0 : _getComputedStyle$con.includes(checkContent);
|
|
(_ele$parentNode = _ele.parentNode) === null || _ele$parentNode === void 0 || _ele$parentNode.removeChild(_ele);
|
|
removeCSS(randomSelectorKey);
|
|
return support;
|
|
}
|
|
return false;
|
|
}
|
|
var canWhere = void 0;
|
|
function supportWhere() {
|
|
if (canWhere === void 0) {
|
|
canWhere = supportSelector(":where(.".concat(randomSelectorKey, ') { content: "').concat(checkContent, '"!important; }'), function(ele) {
|
|
ele.className = randomSelectorKey;
|
|
});
|
|
}
|
|
return canWhere;
|
|
}
|
|
var canLogic = void 0;
|
|
function supportLogicProps() {
|
|
if (canLogic === void 0) {
|
|
canLogic = supportSelector(".".concat(randomSelectorKey, " { inset-block: 93px !important; }"), function(ele) {
|
|
ele.className = randomSelectorKey;
|
|
}, function(ele) {
|
|
return getComputedStyle(ele).bottom === "93px";
|
|
});
|
|
}
|
|
return canLogic;
|
|
}
|
|
var isClientSide = canUseDom();
|
|
function unit2(num) {
|
|
if (typeof num === "number") {
|
|
return "".concat(num, "px");
|
|
}
|
|
return num;
|
|
}
|
|
function toStyleStr(style, tokenKey, styleId) {
|
|
var customizeAttrs = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
|
|
var plain = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
|
|
if (plain) {
|
|
return style;
|
|
}
|
|
var attrs = _objectSpread2(_objectSpread2({}, customizeAttrs), {}, _defineProperty(_defineProperty({}, ATTR_TOKEN, tokenKey), ATTR_MARK, styleId));
|
|
var attrStr = Object.keys(attrs).map(function(attr) {
|
|
var val = attrs[attr];
|
|
return val ? "".concat(attr, '="').concat(val, '"') : null;
|
|
}).filter(function(v) {
|
|
return v;
|
|
}).join(" ");
|
|
return "<style ".concat(attrStr, ">").concat(style, "</style>");
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/util/css-variables.js
|
|
var token2CSSVar = function token2CSSVar2(token2) {
|
|
var prefix2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
|
|
return "--".concat(prefix2 ? "".concat(prefix2, "-") : "").concat(token2).replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1-$2").replace(/([a-z])([A-Z0-9])/g, "$1-$2").toLowerCase();
|
|
};
|
|
var serializeCSSVar = function serializeCSSVar2(cssVars, hashId, options) {
|
|
if (!Object.keys(cssVars).length) {
|
|
return "";
|
|
}
|
|
return ".".concat(hashId).concat(options !== null && options !== void 0 && options.scope ? ".".concat(options.scope) : "", "{").concat(Object.entries(cssVars).map(function(_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1];
|
|
return "".concat(key, ":").concat(value, ";");
|
|
}).join(""), "}");
|
|
};
|
|
var transformToken = function transformToken2(token2, themeKey, config) {
|
|
var cssVars = {};
|
|
var result = {};
|
|
Object.entries(token2).forEach(function(_ref3) {
|
|
var _config$preserve, _config$ignore;
|
|
var _ref4 = _slicedToArray(_ref3, 2), key = _ref4[0], value = _ref4[1];
|
|
if (config !== null && config !== void 0 && (_config$preserve = config.preserve) !== null && _config$preserve !== void 0 && _config$preserve[key]) {
|
|
result[key] = value;
|
|
} else if ((typeof value === "string" || typeof value === "number") && !(config !== null && config !== void 0 && (_config$ignore = config.ignore) !== null && _config$ignore !== void 0 && _config$ignore[key])) {
|
|
var _config$unitless;
|
|
var cssVar = token2CSSVar(key, config === null || config === void 0 ? void 0 : config.prefix);
|
|
cssVars[cssVar] = typeof value === "number" && !(config !== null && config !== void 0 && (_config$unitless = config.unitless) !== null && _config$unitless !== void 0 && _config$unitless[key]) ? "".concat(value, "px") : String(value);
|
|
result[key] = "var(".concat(cssVar, ")");
|
|
}
|
|
});
|
|
return [result, serializeCSSVar(cssVars, themeKey, {
|
|
scope: config === null || config === void 0 ? void 0 : config.scope
|
|
})];
|
|
};
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useGlobalCache.js
|
|
var React5 = __toESM(require_react());
|
|
|
|
// node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
var React2 = __toESM(require_react());
|
|
var useInternalLayoutEffect = canUseDom() ? React2.useLayoutEffect : React2.useEffect;
|
|
var useLayoutEffect2 = function useLayoutEffect3(callback, deps) {
|
|
var firstMountRef = React2.useRef(true);
|
|
useInternalLayoutEffect(function() {
|
|
return callback(firstMountRef.current);
|
|
}, deps);
|
|
useInternalLayoutEffect(function() {
|
|
firstMountRef.current = false;
|
|
return function() {
|
|
firstMountRef.current = true;
|
|
};
|
|
}, []);
|
|
};
|
|
var useLayoutUpdateEffect = function useLayoutUpdateEffect2(callback, deps) {
|
|
useLayoutEffect2(function(firstMount) {
|
|
if (!firstMount) {
|
|
return callback();
|
|
}
|
|
}, deps);
|
|
};
|
|
var useLayoutEffect_default = useLayoutEffect2;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useCompatibleInsertionEffect.js
|
|
var React3 = __toESM(require_react());
|
|
var fullClone = _objectSpread2({}, React3);
|
|
var useInsertionEffect = fullClone.useInsertionEffect;
|
|
var useInsertionEffectPolyfill = function useInsertionEffectPolyfill2(renderEffect, effect, deps) {
|
|
React3.useMemo(renderEffect, deps);
|
|
useLayoutEffect_default(function() {
|
|
return effect(true);
|
|
}, deps);
|
|
};
|
|
var useCompatibleInsertionEffect = useInsertionEffect ? function(renderEffect, effect, deps) {
|
|
return useInsertionEffect(function() {
|
|
renderEffect();
|
|
return effect();
|
|
}, deps);
|
|
} : useInsertionEffectPolyfill;
|
|
var useCompatibleInsertionEffect_default = useCompatibleInsertionEffect;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useEffectCleanupRegister.js
|
|
var React4 = __toESM(require_react());
|
|
var fullClone2 = _objectSpread2({}, React4);
|
|
var useInsertionEffect2 = fullClone2.useInsertionEffect;
|
|
var useCleanupRegister = function useCleanupRegister2(deps) {
|
|
var effectCleanups = [];
|
|
var cleanupFlag = false;
|
|
function register(fn) {
|
|
if (cleanupFlag) {
|
|
if (true) {
|
|
warning(false, "[Ant Design CSS-in-JS] You are registering a cleanup function after unmount, which will not have any effect.");
|
|
}
|
|
return;
|
|
}
|
|
effectCleanups.push(fn);
|
|
}
|
|
React4.useEffect(function() {
|
|
cleanupFlag = false;
|
|
return function() {
|
|
cleanupFlag = true;
|
|
if (effectCleanups.length) {
|
|
effectCleanups.forEach(function(fn) {
|
|
return fn();
|
|
});
|
|
}
|
|
};
|
|
}, deps);
|
|
return register;
|
|
};
|
|
var useRun = function useRun2() {
|
|
return function(fn) {
|
|
fn();
|
|
};
|
|
};
|
|
var useEffectCleanupRegister = typeof useInsertionEffect2 !== "undefined" ? useCleanupRegister : useRun;
|
|
var useEffectCleanupRegister_default = useEffectCleanupRegister;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useHMR.js
|
|
var webpackHMR = false;
|
|
function useDevHMR() {
|
|
return webpackHMR;
|
|
}
|
|
var useHMR_default = false ? useProdHMR : useDevHMR;
|
|
if (typeof module !== "undefined" && module && module.hot && typeof window !== "undefined") {
|
|
win = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : null;
|
|
if (win && typeof win.webpackHotUpdate === "function") {
|
|
originWebpackHotUpdate = win.webpackHotUpdate;
|
|
win.webpackHotUpdate = function() {
|
|
webpackHMR = true;
|
|
setTimeout(function() {
|
|
webpackHMR = false;
|
|
}, 0);
|
|
return originWebpackHotUpdate.apply(void 0, arguments);
|
|
};
|
|
}
|
|
}
|
|
var win;
|
|
var originWebpackHotUpdate;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useGlobalCache.js
|
|
function useGlobalCache(prefix2, keyPath, cacheFn, onCacheRemove, onCacheEffect) {
|
|
var _React$useContext = React5.useContext(StyleContext_default), globalCache = _React$useContext.cache;
|
|
var fullPath = [prefix2].concat(_toConsumableArray(keyPath));
|
|
var fullPathStr = pathKey(fullPath);
|
|
var register = useEffectCleanupRegister_default([fullPathStr]);
|
|
var HMRUpdate = useHMR_default();
|
|
var buildCache = function buildCache2(updater) {
|
|
globalCache.opUpdate(fullPathStr, function(prevCache) {
|
|
var _ref = prevCache || [void 0, void 0], _ref2 = _slicedToArray(_ref, 2), _ref2$ = _ref2[0], times = _ref2$ === void 0 ? 0 : _ref2$, cache = _ref2[1];
|
|
var tmpCache = cache;
|
|
if (cache && HMRUpdate) {
|
|
onCacheRemove === null || onCacheRemove === void 0 || onCacheRemove(tmpCache, HMRUpdate);
|
|
tmpCache = null;
|
|
}
|
|
var mergedCache = tmpCache || cacheFn();
|
|
var data = [times, mergedCache];
|
|
return updater ? updater(data) : data;
|
|
});
|
|
};
|
|
React5.useMemo(
|
|
function() {
|
|
buildCache();
|
|
},
|
|
/* eslint-disable react-hooks/exhaustive-deps */
|
|
[fullPathStr]
|
|
/* eslint-enable */
|
|
);
|
|
var cacheEntity = globalCache.opGet(fullPathStr);
|
|
if (!cacheEntity) {
|
|
buildCache();
|
|
cacheEntity = globalCache.opGet(fullPathStr);
|
|
}
|
|
var cacheContent = cacheEntity[1];
|
|
useCompatibleInsertionEffect_default(function() {
|
|
onCacheEffect === null || onCacheEffect === void 0 || onCacheEffect(cacheContent);
|
|
}, function(polyfill) {
|
|
buildCache(function(_ref3) {
|
|
var _ref4 = _slicedToArray(_ref3, 2), times = _ref4[0], cache = _ref4[1];
|
|
if (polyfill && times === 0) {
|
|
onCacheEffect === null || onCacheEffect === void 0 || onCacheEffect(cacheContent);
|
|
}
|
|
return [times + 1, cache];
|
|
});
|
|
return function() {
|
|
globalCache.opUpdate(fullPathStr, function(prevCache) {
|
|
var _ref5 = prevCache || [], _ref6 = _slicedToArray(_ref5, 2), _ref6$ = _ref6[0], times = _ref6$ === void 0 ? 0 : _ref6$, cache = _ref6[1];
|
|
var nextCount = times - 1;
|
|
if (nextCount === 0) {
|
|
register(function() {
|
|
if (polyfill || !globalCache.opGet(fullPathStr)) {
|
|
onCacheRemove === null || onCacheRemove === void 0 || onCacheRemove(cache, false);
|
|
}
|
|
});
|
|
return null;
|
|
}
|
|
return [times - 1, cache];
|
|
});
|
|
};
|
|
}, [fullPathStr]);
|
|
return cacheContent;
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useCacheToken.js
|
|
var EMPTY_OVERRIDE = {};
|
|
var hashPrefix = true ? "css-dev-only-do-not-override" : "css";
|
|
var tokenKeys = /* @__PURE__ */ new Map();
|
|
function recordCleanToken(tokenKey) {
|
|
tokenKeys.set(tokenKey, (tokenKeys.get(tokenKey) || 0) + 1);
|
|
}
|
|
function removeStyleTags(key, instanceId) {
|
|
if (typeof document !== "undefined") {
|
|
var styles = document.querySelectorAll("style[".concat(ATTR_TOKEN, '="').concat(key, '"]'));
|
|
styles.forEach(function(style) {
|
|
if (style[CSS_IN_JS_INSTANCE] === instanceId) {
|
|
var _style$parentNode;
|
|
(_style$parentNode = style.parentNode) === null || _style$parentNode === void 0 || _style$parentNode.removeChild(style);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
var TOKEN_THRESHOLD = 0;
|
|
function cleanTokenStyle(tokenKey, instanceId) {
|
|
tokenKeys.set(tokenKey, (tokenKeys.get(tokenKey) || 0) - 1);
|
|
var cleanableKeyList = /* @__PURE__ */ new Set();
|
|
tokenKeys.forEach(function(value, key) {
|
|
if (value <= 0) cleanableKeyList.add(key);
|
|
});
|
|
if (tokenKeys.size - cleanableKeyList.size > TOKEN_THRESHOLD) {
|
|
cleanableKeyList.forEach(function(key) {
|
|
removeStyleTags(key, instanceId);
|
|
tokenKeys.delete(key);
|
|
});
|
|
}
|
|
}
|
|
var getComputedToken = function getComputedToken2(originToken, overrideToken, theme, format) {
|
|
var derivativeToken = theme.getDerivativeToken(originToken);
|
|
var mergedDerivativeToken = _objectSpread2(_objectSpread2({}, derivativeToken), overrideToken);
|
|
if (format) {
|
|
mergedDerivativeToken = format(mergedDerivativeToken);
|
|
}
|
|
return mergedDerivativeToken;
|
|
};
|
|
var TOKEN_PREFIX = "token";
|
|
function useCacheToken(theme, tokens) {
|
|
var option = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
|
var _useContext = (0, import_react.useContext)(StyleContext_default), instanceId = _useContext.cache.instanceId, container = _useContext.container;
|
|
var _option$salt = option.salt, salt = _option$salt === void 0 ? "" : _option$salt, _option$override = option.override, override = _option$override === void 0 ? EMPTY_OVERRIDE : _option$override, formatToken = option.formatToken, compute = option.getComputedToken, cssVar = option.cssVar;
|
|
var mergedToken = memoResult(function() {
|
|
return Object.assign.apply(Object, [{}].concat(_toConsumableArray(tokens)));
|
|
}, tokens);
|
|
var tokenStr = flattenToken(mergedToken);
|
|
var overrideTokenStr = flattenToken(override);
|
|
var cssVarStr = cssVar ? flattenToken(cssVar) : "";
|
|
var cachedToken = useGlobalCache(TOKEN_PREFIX, [salt, theme.id, tokenStr, overrideTokenStr, cssVarStr], function() {
|
|
var _cssVar$key;
|
|
var mergedDerivativeToken = compute ? compute(mergedToken, override, theme) : getComputedToken(mergedToken, override, theme, formatToken);
|
|
var actualToken = _objectSpread2({}, mergedDerivativeToken);
|
|
var cssVarsStr = "";
|
|
if (!!cssVar) {
|
|
var _transformToken = transformToken(mergedDerivativeToken, cssVar.key, {
|
|
prefix: cssVar.prefix,
|
|
ignore: cssVar.ignore,
|
|
unitless: cssVar.unitless,
|
|
preserve: cssVar.preserve
|
|
});
|
|
var _transformToken2 = _slicedToArray(_transformToken, 2);
|
|
mergedDerivativeToken = _transformToken2[0];
|
|
cssVarsStr = _transformToken2[1];
|
|
}
|
|
var tokenKey = token2key(mergedDerivativeToken, salt);
|
|
mergedDerivativeToken._tokenKey = tokenKey;
|
|
actualToken._tokenKey = token2key(actualToken, salt);
|
|
var themeKey = (_cssVar$key = cssVar === null || cssVar === void 0 ? void 0 : cssVar.key) !== null && _cssVar$key !== void 0 ? _cssVar$key : tokenKey;
|
|
mergedDerivativeToken._themeKey = themeKey;
|
|
recordCleanToken(themeKey);
|
|
var hashId = "".concat(hashPrefix, "-").concat(hash_browser_esm_default(tokenKey));
|
|
mergedDerivativeToken._hashId = hashId;
|
|
return [mergedDerivativeToken, hashId, actualToken, cssVarsStr, (cssVar === null || cssVar === void 0 ? void 0 : cssVar.key) || ""];
|
|
}, function(cache) {
|
|
cleanTokenStyle(cache[0]._themeKey, instanceId);
|
|
}, function(_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 4), token2 = _ref2[0], cssVarsStr = _ref2[3];
|
|
if (cssVar && cssVarsStr) {
|
|
var style = updateCSS(cssVarsStr, hash_browser_esm_default("css-variables-".concat(token2._themeKey)), {
|
|
mark: ATTR_MARK,
|
|
prepend: "queue",
|
|
attachTo: container,
|
|
priority: -999
|
|
});
|
|
style[CSS_IN_JS_INSTANCE] = instanceId;
|
|
style.setAttribute(ATTR_TOKEN, token2._themeKey);
|
|
}
|
|
});
|
|
return cachedToken;
|
|
}
|
|
var extract = function extract2(cache, effectStyles, options) {
|
|
var _cache = _slicedToArray(cache, 5), realToken = _cache[2], styleStr = _cache[3], cssVarKey = _cache[4];
|
|
var _ref3 = options || {}, plain = _ref3.plain;
|
|
if (!styleStr) {
|
|
return null;
|
|
}
|
|
var styleId = realToken._tokenKey;
|
|
var order = -999;
|
|
var sharedAttrs = {
|
|
"data-rc-order": "prependQueue",
|
|
"data-rc-priority": "".concat(order)
|
|
};
|
|
var styleText = toStyleStr(styleStr, cssVarKey, styleId, sharedAttrs, plain);
|
|
return [order, styleId, styleText];
|
|
};
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useCSSVarRegister.js
|
|
var import_react2 = __toESM(require_react());
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useStyleRegister.js
|
|
init_defineProperty();
|
|
init_typeof();
|
|
var React6 = __toESM(require_react());
|
|
|
|
// node_modules/@emotion/unitless/dist/unitless.browser.esm.js
|
|
var unitlessKeys = {
|
|
animationIterationCount: 1,
|
|
borderImageOutset: 1,
|
|
borderImageSlice: 1,
|
|
borderImageWidth: 1,
|
|
boxFlex: 1,
|
|
boxFlexGroup: 1,
|
|
boxOrdinalGroup: 1,
|
|
columnCount: 1,
|
|
columns: 1,
|
|
flex: 1,
|
|
flexGrow: 1,
|
|
flexPositive: 1,
|
|
flexShrink: 1,
|
|
flexNegative: 1,
|
|
flexOrder: 1,
|
|
gridRow: 1,
|
|
gridRowEnd: 1,
|
|
gridRowSpan: 1,
|
|
gridRowStart: 1,
|
|
gridColumn: 1,
|
|
gridColumnEnd: 1,
|
|
gridColumnSpan: 1,
|
|
gridColumnStart: 1,
|
|
msGridRow: 1,
|
|
msGridRowSpan: 1,
|
|
msGridColumn: 1,
|
|
msGridColumnSpan: 1,
|
|
fontWeight: 1,
|
|
lineHeight: 1,
|
|
opacity: 1,
|
|
order: 1,
|
|
orphans: 1,
|
|
tabSize: 1,
|
|
widows: 1,
|
|
zIndex: 1,
|
|
zoom: 1,
|
|
WebkitLineClamp: 1,
|
|
// SVG-related properties
|
|
fillOpacity: 1,
|
|
floodOpacity: 1,
|
|
stopOpacity: 1,
|
|
strokeDasharray: 1,
|
|
strokeDashoffset: 1,
|
|
strokeMiterlimit: 1,
|
|
strokeOpacity: 1,
|
|
strokeWidth: 1
|
|
};
|
|
var unitless_browser_esm_default = unitlessKeys;
|
|
|
|
// node_modules/stylis/src/Enum.js
|
|
var COMMENT = "comm";
|
|
var RULESET = "rule";
|
|
var DECLARATION = "decl";
|
|
var IMPORT = "@import";
|
|
var NAMESPACE = "@namespace";
|
|
var KEYFRAMES = "@keyframes";
|
|
var LAYER = "@layer";
|
|
|
|
// node_modules/stylis/src/Utility.js
|
|
var abs = Math.abs;
|
|
var from = String.fromCharCode;
|
|
function trim(value) {
|
|
return value.trim();
|
|
}
|
|
function replace(value, pattern, replacement) {
|
|
return value.replace(pattern, replacement);
|
|
}
|
|
function indexof(value, search, position2) {
|
|
return value.indexOf(search, position2);
|
|
}
|
|
function charat(value, index) {
|
|
return value.charCodeAt(index) | 0;
|
|
}
|
|
function substr(value, begin, end) {
|
|
return value.slice(begin, end);
|
|
}
|
|
function strlen(value) {
|
|
return value.length;
|
|
}
|
|
function sizeof(value) {
|
|
return value.length;
|
|
}
|
|
function append(value, array) {
|
|
return array.push(value), value;
|
|
}
|
|
|
|
// node_modules/stylis/src/Tokenizer.js
|
|
var line = 1;
|
|
var column = 1;
|
|
var length = 0;
|
|
var position = 0;
|
|
var character = 0;
|
|
var characters = "";
|
|
function node(value, root, parent, type, props, children, length2, siblings) {
|
|
return { value, root, parent, type, props, children, line, column, length: length2, return: "", siblings };
|
|
}
|
|
function char() {
|
|
return character;
|
|
}
|
|
function prev() {
|
|
character = position > 0 ? charat(characters, --position) : 0;
|
|
if (column--, character === 10)
|
|
column = 1, line--;
|
|
return character;
|
|
}
|
|
function next() {
|
|
character = position < length ? charat(characters, position++) : 0;
|
|
if (column++, character === 10)
|
|
column = 1, line++;
|
|
return character;
|
|
}
|
|
function peek() {
|
|
return charat(characters, position);
|
|
}
|
|
function caret() {
|
|
return position;
|
|
}
|
|
function slice(begin, end) {
|
|
return substr(characters, begin, end);
|
|
}
|
|
function token(type) {
|
|
switch (type) {
|
|
// \0 \t \n \r \s whitespace token
|
|
case 0:
|
|
case 9:
|
|
case 10:
|
|
case 13:
|
|
case 32:
|
|
return 5;
|
|
// ! + , / > @ ~ isolate token
|
|
case 33:
|
|
case 43:
|
|
case 44:
|
|
case 47:
|
|
case 62:
|
|
case 64:
|
|
case 126:
|
|
// ; { } breakpoint token
|
|
case 59:
|
|
case 123:
|
|
case 125:
|
|
return 4;
|
|
// : accompanied token
|
|
case 58:
|
|
return 3;
|
|
// " ' ( [ opening delimit token
|
|
case 34:
|
|
case 39:
|
|
case 40:
|
|
case 91:
|
|
return 2;
|
|
// ) ] closing delimit token
|
|
case 41:
|
|
case 93:
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
function alloc(value) {
|
|
return line = column = 1, length = strlen(characters = value), position = 0, [];
|
|
}
|
|
function dealloc(value) {
|
|
return characters = "", value;
|
|
}
|
|
function delimit(type) {
|
|
return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
|
|
}
|
|
function whitespace(type) {
|
|
while (character = peek())
|
|
if (character < 33)
|
|
next();
|
|
else
|
|
break;
|
|
return token(type) > 2 || token(character) > 3 ? "" : " ";
|
|
}
|
|
function escaping(index, count) {
|
|
while (--count && next())
|
|
if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97)
|
|
break;
|
|
return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32));
|
|
}
|
|
function delimiter(type) {
|
|
while (next())
|
|
switch (character) {
|
|
// ] ) " '
|
|
case type:
|
|
return position;
|
|
// " '
|
|
case 34:
|
|
case 39:
|
|
if (type !== 34 && type !== 39)
|
|
delimiter(character);
|
|
break;
|
|
// (
|
|
case 40:
|
|
if (type === 41)
|
|
delimiter(type);
|
|
break;
|
|
// \
|
|
case 92:
|
|
next();
|
|
break;
|
|
}
|
|
return position;
|
|
}
|
|
function commenter(type, index) {
|
|
while (next())
|
|
if (type + character === 47 + 10)
|
|
break;
|
|
else if (type + character === 42 + 42 && peek() === 47)
|
|
break;
|
|
return "/*" + slice(index, position - 1) + "*" + from(type === 47 ? type : next());
|
|
}
|
|
function identifier(index) {
|
|
while (!token(peek()))
|
|
next();
|
|
return slice(index, position);
|
|
}
|
|
|
|
// node_modules/stylis/src/Parser.js
|
|
function compile(value) {
|
|
return dealloc(parse("", null, null, null, [""], value = alloc(value), 0, [0], value));
|
|
}
|
|
function parse(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
|
|
var index = 0;
|
|
var offset = 0;
|
|
var length2 = pseudo;
|
|
var atrule = 0;
|
|
var property = 0;
|
|
var previous = 0;
|
|
var variable = 1;
|
|
var scanning = 1;
|
|
var ampersand = 1;
|
|
var character2 = 0;
|
|
var type = "";
|
|
var props = rules;
|
|
var children = rulesets;
|
|
var reference = rule;
|
|
var characters2 = type;
|
|
while (scanning)
|
|
switch (previous = character2, character2 = next()) {
|
|
// (
|
|
case 40:
|
|
if (previous != 108 && charat(characters2, length2 - 1) == 58) {
|
|
if (indexof(characters2 += replace(delimit(character2), "&", "&\f"), "&\f", abs(index ? points[index - 1] : 0)) != -1)
|
|
ampersand = -1;
|
|
break;
|
|
}
|
|
// " ' [
|
|
case 34:
|
|
case 39:
|
|
case 91:
|
|
characters2 += delimit(character2);
|
|
break;
|
|
// \t \n \r \s
|
|
case 9:
|
|
case 10:
|
|
case 13:
|
|
case 32:
|
|
characters2 += whitespace(previous);
|
|
break;
|
|
// \
|
|
case 92:
|
|
characters2 += escaping(caret() - 1, 7);
|
|
continue;
|
|
// /
|
|
case 47:
|
|
switch (peek()) {
|
|
case 42:
|
|
case 47:
|
|
append(comment(commenter(next(), caret()), root, parent, declarations), declarations);
|
|
if ((token(previous || 1) == 5 || token(peek() || 1) == 5) && strlen(characters2) && substr(characters2, -1, void 0) !== " ") characters2 += " ";
|
|
break;
|
|
default:
|
|
characters2 += "/";
|
|
}
|
|
break;
|
|
// {
|
|
case 123 * variable:
|
|
points[index++] = strlen(characters2) * ampersand;
|
|
// } ; \0
|
|
case 125 * variable:
|
|
case 59:
|
|
case 0:
|
|
switch (character2) {
|
|
// \0 }
|
|
case 0:
|
|
case 125:
|
|
scanning = 0;
|
|
// ;
|
|
case 59 + offset:
|
|
if (ampersand == -1) characters2 = replace(characters2, /\f/g, "");
|
|
if (property > 0 && (strlen(characters2) - length2 || variable === 0 && previous === 47))
|
|
append(property > 32 ? declaration(characters2 + ";", rule, parent, length2 - 1, declarations) : declaration(replace(characters2, " ", "") + ";", rule, parent, length2 - 2, declarations), declarations);
|
|
break;
|
|
// @ ;
|
|
case 59:
|
|
characters2 += ";";
|
|
// { rule/at-rule
|
|
default:
|
|
append(reference = ruleset(characters2, root, parent, index, offset, rules, points, type, props = [], children = [], length2, rulesets), rulesets);
|
|
if (character2 === 123)
|
|
if (offset === 0)
|
|
parse(characters2, root, reference, reference, props, rulesets, length2, points, children);
|
|
else {
|
|
switch (atrule) {
|
|
// c(ontainer)
|
|
case 99:
|
|
if (charat(characters2, 3) === 110) break;
|
|
// l(ayer)
|
|
case 108:
|
|
if (charat(characters2, 2) === 97) break;
|
|
default:
|
|
offset = 0;
|
|
// d(ocument) m(edia) s(upports)
|
|
case 100:
|
|
case 109:
|
|
case 115:
|
|
}
|
|
if (offset) parse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length2, children), children), rules, children, length2, points, rule ? props : children);
|
|
else parse(characters2, reference, reference, reference, [""], children, 0, points, children);
|
|
}
|
|
}
|
|
index = offset = property = 0, variable = ampersand = 1, type = characters2 = "", length2 = pseudo;
|
|
break;
|
|
// :
|
|
case 58:
|
|
length2 = 1 + strlen(characters2), property = previous;
|
|
default:
|
|
if (variable < 1) {
|
|
if (character2 == 123)
|
|
--variable;
|
|
else if (character2 == 125 && variable++ == 0 && prev() == 125)
|
|
continue;
|
|
}
|
|
switch (characters2 += from(character2), character2 * variable) {
|
|
// &
|
|
case 38:
|
|
ampersand = offset > 0 ? 1 : (characters2 += "\f", -1);
|
|
break;
|
|
// ,
|
|
case 44:
|
|
points[index++] = (strlen(characters2) - 1) * ampersand, ampersand = 1;
|
|
break;
|
|
// @
|
|
case 64:
|
|
if (peek() === 45)
|
|
characters2 += delimit(next());
|
|
atrule = peek(), offset = length2 = strlen(type = characters2 += identifier(caret())), character2++;
|
|
break;
|
|
// -
|
|
case 45:
|
|
if (previous === 45 && strlen(characters2) == 2)
|
|
variable = 0;
|
|
}
|
|
}
|
|
return rulesets;
|
|
}
|
|
function ruleset(value, root, parent, index, offset, rules, points, type, props, children, length2, siblings) {
|
|
var post = offset - 1;
|
|
var rule = offset === 0 ? rules : [""];
|
|
var size = sizeof(rule);
|
|
for (var i = 0, j = 0, k = 0; i < index; ++i)
|
|
for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
|
|
if (z = trim(j > 0 ? rule[x] + " " + y : replace(y, /&\f/g, rule[x])))
|
|
props[k++] = z;
|
|
return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length2, siblings);
|
|
}
|
|
function comment(value, root, parent, siblings) {
|
|
return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0, siblings);
|
|
}
|
|
function declaration(value, root, parent, length2, siblings) {
|
|
return node(value, root, parent, DECLARATION, substr(value, 0, length2), substr(value, length2 + 1, -1), length2, siblings);
|
|
}
|
|
|
|
// node_modules/stylis/src/Serializer.js
|
|
function serialize(children, callback) {
|
|
var output = "";
|
|
for (var i = 0; i < children.length; i++)
|
|
output += callback(children[i], i, children, callback) || "";
|
|
return output;
|
|
}
|
|
function stringify(element, index, children, callback) {
|
|
switch (element.type) {
|
|
case LAYER:
|
|
if (element.children.length) break;
|
|
case IMPORT:
|
|
case NAMESPACE:
|
|
case DECLARATION:
|
|
return element.return = element.return || element.value;
|
|
case COMMENT:
|
|
return "";
|
|
case KEYFRAMES:
|
|
return element.return = element.value + "{" + serialize(element.children, callback) + "}";
|
|
case RULESET:
|
|
if (!strlen(element.value = element.props.join(","))) return "";
|
|
}
|
|
return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/utils.js
|
|
function lintWarning(message, info) {
|
|
var path = info.path, parentSelectors = info.parentSelectors;
|
|
warning_default(false, "[Ant Design CSS-in-JS] ".concat(path ? "Error in ".concat(path, ": ") : "").concat(message).concat(parentSelectors.length ? " Selector: ".concat(parentSelectors.join(" | ")) : ""));
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/contentQuotesLinter.js
|
|
var linter = function linter2(key, value, info) {
|
|
if (key === "content") {
|
|
var contentValuePattern = /(attr|counters?|url|(((repeating-)?(linear|radial))|conic)-gradient)\(|(no-)?(open|close)-quote/;
|
|
var contentValues = ["normal", "none", "initial", "inherit", "unset"];
|
|
if (typeof value !== "string" || contentValues.indexOf(value) === -1 && !contentValuePattern.test(value) && (value.charAt(0) !== value.charAt(value.length - 1) || value.charAt(0) !== '"' && value.charAt(0) !== "'")) {
|
|
lintWarning("You seem to be using a value for 'content' without quotes, try replacing it with `content: '\"".concat(value, "\"'`."), info);
|
|
}
|
|
}
|
|
};
|
|
var contentQuotesLinter_default = linter;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/hashedAnimationLinter.js
|
|
var linter3 = function linter4(key, value, info) {
|
|
if (key === "animation") {
|
|
if (info.hashId && value !== "none") {
|
|
lintWarning("You seem to be using hashed animation '".concat(value, "', in which case 'animationName' with Keyframe as value is recommended."), info);
|
|
}
|
|
}
|
|
};
|
|
var hashedAnimationLinter_default = linter3;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/legacyNotSelectorLinter.js
|
|
function isConcatSelector(selector) {
|
|
var _selector$match;
|
|
var notContent = ((_selector$match = selector.match(/:not\(([^)]*)\)/)) === null || _selector$match === void 0 ? void 0 : _selector$match[1]) || "";
|
|
var splitCells = notContent.split(/(\[[^[]*])|(?=[.#])/).filter(function(str) {
|
|
return str;
|
|
});
|
|
return splitCells.length > 1;
|
|
}
|
|
function parsePath(info) {
|
|
return info.parentSelectors.reduce(function(prev2, cur) {
|
|
if (!prev2) {
|
|
return cur;
|
|
}
|
|
return cur.includes("&") ? cur.replace(/&/g, prev2) : "".concat(prev2, " ").concat(cur);
|
|
}, "");
|
|
}
|
|
var linter5 = function linter6(key, value, info) {
|
|
var parentSelectorPath = parsePath(info);
|
|
var notList = parentSelectorPath.match(/:not\([^)]*\)/g) || [];
|
|
if (notList.length > 0 && notList.some(isConcatSelector)) {
|
|
lintWarning("Concat ':not' selector not support in legacy browsers.", info);
|
|
}
|
|
};
|
|
var legacyNotSelectorLinter_default = linter5;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/logicalPropertiesLinter.js
|
|
var linter7 = function linter8(key, value, info) {
|
|
switch (key) {
|
|
case "marginLeft":
|
|
case "marginRight":
|
|
case "paddingLeft":
|
|
case "paddingRight":
|
|
case "left":
|
|
case "right":
|
|
case "borderLeft":
|
|
case "borderLeftWidth":
|
|
case "borderLeftStyle":
|
|
case "borderLeftColor":
|
|
case "borderRight":
|
|
case "borderRightWidth":
|
|
case "borderRightStyle":
|
|
case "borderRightColor":
|
|
case "borderTopLeftRadius":
|
|
case "borderTopRightRadius":
|
|
case "borderBottomLeftRadius":
|
|
case "borderBottomRightRadius":
|
|
lintWarning("You seem to be using non-logical property '".concat(key, "' which is not compatible with RTL mode. Please use logical properties and values instead. For more information: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties."), info);
|
|
return;
|
|
case "margin":
|
|
case "padding":
|
|
case "borderWidth":
|
|
case "borderStyle":
|
|
if (typeof value === "string") {
|
|
var valueArr = value.split(" ").map(function(item) {
|
|
return item.trim();
|
|
});
|
|
if (valueArr.length === 4 && valueArr[1] !== valueArr[3]) {
|
|
lintWarning("You seem to be using '".concat(key, "' property with different left ").concat(key, " and right ").concat(key, ", which is not compatible with RTL mode. Please use logical properties and values instead. For more information: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties."), info);
|
|
}
|
|
}
|
|
return;
|
|
case "clear":
|
|
case "textAlign":
|
|
if (value === "left" || value === "right") {
|
|
lintWarning("You seem to be using non-logical value '".concat(value, "' of ").concat(key, ", which is not compatible with RTL mode. Please use logical properties and values instead. For more information: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties."), info);
|
|
}
|
|
return;
|
|
case "borderRadius":
|
|
if (typeof value === "string") {
|
|
var radiusGroups = value.split("/").map(function(item) {
|
|
return item.trim();
|
|
});
|
|
var invalid = radiusGroups.reduce(function(result, group) {
|
|
if (result) {
|
|
return result;
|
|
}
|
|
var radiusArr = group.split(" ").map(function(item) {
|
|
return item.trim();
|
|
});
|
|
if (radiusArr.length >= 2 && radiusArr[0] !== radiusArr[1]) {
|
|
return true;
|
|
}
|
|
if (radiusArr.length === 3 && radiusArr[1] !== radiusArr[2]) {
|
|
return true;
|
|
}
|
|
if (radiusArr.length === 4 && radiusArr[2] !== radiusArr[3]) {
|
|
return true;
|
|
}
|
|
return result;
|
|
}, false);
|
|
if (invalid) {
|
|
lintWarning("You seem to be using non-logical value '".concat(value, "' of ").concat(key, ", which is not compatible with RTL mode. Please use logical properties and values instead. For more information: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties."), info);
|
|
}
|
|
}
|
|
return;
|
|
default:
|
|
}
|
|
};
|
|
var logicalPropertiesLinter_default = linter7;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/NaNLinter.js
|
|
var linter9 = function linter10(key, value, info) {
|
|
if (typeof value === "string" && /NaN/g.test(value) || Number.isNaN(value)) {
|
|
lintWarning("Unexpected 'NaN' in property '".concat(key, ": ").concat(value, "'."), info);
|
|
}
|
|
};
|
|
var NaNLinter_default = linter9;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/linters/parentSelectorLinter.js
|
|
var linter11 = function linter12(key, value, info) {
|
|
if (info.parentSelectors.some(function(selector) {
|
|
var selectors = selector.split(",");
|
|
return selectors.some(function(item) {
|
|
return item.split("&").length > 2;
|
|
});
|
|
})) {
|
|
lintWarning("Should not use more than one `&` in a selector.", info);
|
|
}
|
|
};
|
|
var parentSelectorLinter_default = linter11;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/util/cacheMapUtil.js
|
|
var ATTR_CACHE_MAP = "data-ant-cssinjs-cache-path";
|
|
var CSS_FILE_STYLE = "_FILE_STYLE__";
|
|
function serialize2(cachePathMap2) {
|
|
return Object.keys(cachePathMap2).map(function(path) {
|
|
var hash2 = cachePathMap2[path];
|
|
return "".concat(path, ":").concat(hash2);
|
|
}).join(";");
|
|
}
|
|
var cachePathMap;
|
|
var fromCSSFile = true;
|
|
function prepare() {
|
|
if (!cachePathMap) {
|
|
cachePathMap = {};
|
|
if (canUseDom()) {
|
|
var div = document.createElement("div");
|
|
div.className = ATTR_CACHE_MAP;
|
|
div.style.position = "fixed";
|
|
div.style.visibility = "hidden";
|
|
div.style.top = "-9999px";
|
|
document.body.appendChild(div);
|
|
var content = getComputedStyle(div).content || "";
|
|
content = content.replace(/^"/, "").replace(/"$/, "");
|
|
content.split(";").forEach(function(item) {
|
|
var _item$split = item.split(":"), _item$split2 = _slicedToArray(_item$split, 2), path = _item$split2[0], hash2 = _item$split2[1];
|
|
cachePathMap[path] = hash2;
|
|
});
|
|
var inlineMapStyle = document.querySelector("style[".concat(ATTR_CACHE_MAP, "]"));
|
|
if (inlineMapStyle) {
|
|
var _inlineMapStyle$paren;
|
|
fromCSSFile = false;
|
|
(_inlineMapStyle$paren = inlineMapStyle.parentNode) === null || _inlineMapStyle$paren === void 0 || _inlineMapStyle$paren.removeChild(inlineMapStyle);
|
|
}
|
|
document.body.removeChild(div);
|
|
}
|
|
}
|
|
}
|
|
function existPath(path) {
|
|
prepare();
|
|
return !!cachePathMap[path];
|
|
}
|
|
function getStyleAndHash(path) {
|
|
var hash2 = cachePathMap[path];
|
|
var styleStr = null;
|
|
if (hash2 && canUseDom()) {
|
|
if (fromCSSFile) {
|
|
styleStr = CSS_FILE_STYLE;
|
|
} else {
|
|
var _style = document.querySelector("style[".concat(ATTR_MARK, '="').concat(cachePathMap[path], '"]'));
|
|
if (_style) {
|
|
styleStr = _style.innerHTML;
|
|
} else {
|
|
delete cachePathMap[path];
|
|
}
|
|
}
|
|
}
|
|
return [styleStr, hash2];
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useStyleRegister.js
|
|
var SKIP_CHECK = "_skip_check_";
|
|
var MULTI_VALUE = "_multi_value_";
|
|
function normalizeStyle(styleStr) {
|
|
var serialized = serialize(compile(styleStr), stringify);
|
|
return serialized.replace(/\{%%%\:[^;];}/g, ";");
|
|
}
|
|
function isCompoundCSSProperty(value) {
|
|
return _typeof(value) === "object" && value && (SKIP_CHECK in value || MULTI_VALUE in value);
|
|
}
|
|
function injectSelectorHash(key, hashId, hashPriority) {
|
|
if (!hashId) {
|
|
return key;
|
|
}
|
|
var hashClassName = ".".concat(hashId);
|
|
var hashSelector = hashPriority === "low" ? ":where(".concat(hashClassName, ")") : hashClassName;
|
|
var keys = key.split(",").map(function(k) {
|
|
var _firstPath$match;
|
|
var fullPath = k.trim().split(/\s+/);
|
|
var firstPath = fullPath[0] || "";
|
|
var htmlElement = ((_firstPath$match = firstPath.match(/^\w+/)) === null || _firstPath$match === void 0 ? void 0 : _firstPath$match[0]) || "";
|
|
firstPath = "".concat(htmlElement).concat(hashSelector).concat(firstPath.slice(htmlElement.length));
|
|
return [firstPath].concat(_toConsumableArray(fullPath.slice(1))).join(" ");
|
|
});
|
|
return keys.join(",");
|
|
}
|
|
var parseStyle = function parseStyle2(interpolation) {
|
|
var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
|
|
var _ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
|
|
root: true,
|
|
parentSelectors: []
|
|
}, root = _ref.root, injectHash = _ref.injectHash, parentSelectors = _ref.parentSelectors;
|
|
var hashId = config.hashId, layer = config.layer, path = config.path, hashPriority = config.hashPriority, _config$transformers = config.transformers, transformers = _config$transformers === void 0 ? [] : _config$transformers, _config$linters = config.linters, linters = _config$linters === void 0 ? [] : _config$linters;
|
|
var styleStr = "";
|
|
var effectStyle = {};
|
|
function parseKeyframes(keyframes) {
|
|
var animationName = keyframes.getName(hashId);
|
|
if (!effectStyle[animationName]) {
|
|
var _parseStyle = parseStyle2(keyframes.style, config, {
|
|
root: false,
|
|
parentSelectors
|
|
}), _parseStyle2 = _slicedToArray(_parseStyle, 1), _parsedStr = _parseStyle2[0];
|
|
effectStyle[animationName] = "@keyframes ".concat(keyframes.getName(hashId)).concat(_parsedStr);
|
|
}
|
|
}
|
|
function flattenList(list) {
|
|
var fullList = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
|
|
list.forEach(function(item) {
|
|
if (Array.isArray(item)) {
|
|
flattenList(item, fullList);
|
|
} else if (item) {
|
|
fullList.push(item);
|
|
}
|
|
});
|
|
return fullList;
|
|
}
|
|
var flattenStyleList = flattenList(Array.isArray(interpolation) ? interpolation : [interpolation]);
|
|
flattenStyleList.forEach(function(originStyle) {
|
|
var style = typeof originStyle === "string" && !root ? {} : originStyle;
|
|
if (typeof style === "string") {
|
|
styleStr += "".concat(style, "\n");
|
|
} else if (style._keyframe) {
|
|
parseKeyframes(style);
|
|
} else {
|
|
var mergedStyle = transformers.reduce(function(prev2, trans) {
|
|
var _trans$visit;
|
|
return (trans === null || trans === void 0 || (_trans$visit = trans.visit) === null || _trans$visit === void 0 ? void 0 : _trans$visit.call(trans, prev2)) || prev2;
|
|
}, style);
|
|
Object.keys(mergedStyle).forEach(function(key) {
|
|
var value = mergedStyle[key];
|
|
if (_typeof(value) === "object" && value && (key !== "animationName" || !value._keyframe) && !isCompoundCSSProperty(value)) {
|
|
var subInjectHash = false;
|
|
var mergedKey = key.trim();
|
|
var nextRoot = false;
|
|
if ((root || injectHash) && hashId) {
|
|
if (mergedKey.startsWith("@")) {
|
|
subInjectHash = true;
|
|
} else if (mergedKey === "&") {
|
|
mergedKey = injectSelectorHash("", hashId, hashPriority);
|
|
} else {
|
|
mergedKey = injectSelectorHash(key, hashId, hashPriority);
|
|
}
|
|
} else if (root && !hashId && (mergedKey === "&" || mergedKey === "")) {
|
|
mergedKey = "";
|
|
nextRoot = true;
|
|
}
|
|
var _parseStyle3 = parseStyle2(value, config, {
|
|
root: nextRoot,
|
|
injectHash: subInjectHash,
|
|
parentSelectors: [].concat(_toConsumableArray(parentSelectors), [mergedKey])
|
|
}), _parseStyle4 = _slicedToArray(_parseStyle3, 2), _parsedStr2 = _parseStyle4[0], childEffectStyle = _parseStyle4[1];
|
|
effectStyle = _objectSpread2(_objectSpread2({}, effectStyle), childEffectStyle);
|
|
styleStr += "".concat(mergedKey).concat(_parsedStr2);
|
|
} else {
|
|
let appendStyle = function(cssKey, cssValue) {
|
|
if (_typeof(value) !== "object" || !(value !== null && value !== void 0 && value[SKIP_CHECK])) {
|
|
[contentQuotesLinter_default, hashedAnimationLinter_default].concat(_toConsumableArray(linters)).forEach(function(linter13) {
|
|
return linter13(cssKey, cssValue, {
|
|
path,
|
|
hashId,
|
|
parentSelectors
|
|
});
|
|
});
|
|
}
|
|
var styleName = cssKey.replace(/[A-Z]/g, function(match2) {
|
|
return "-".concat(match2.toLowerCase());
|
|
});
|
|
var formatValue = cssValue;
|
|
if (!unitless_browser_esm_default[cssKey] && typeof formatValue === "number" && formatValue !== 0) {
|
|
formatValue = "".concat(formatValue, "px");
|
|
}
|
|
if (cssKey === "animationName" && cssValue !== null && cssValue !== void 0 && cssValue._keyframe) {
|
|
parseKeyframes(cssValue);
|
|
formatValue = cssValue.getName(hashId);
|
|
}
|
|
styleStr += "".concat(styleName, ":").concat(formatValue, ";");
|
|
};
|
|
var _value;
|
|
var actualValue = (_value = value === null || value === void 0 ? void 0 : value.value) !== null && _value !== void 0 ? _value : value;
|
|
if (_typeof(value) === "object" && value !== null && value !== void 0 && value[MULTI_VALUE] && Array.isArray(actualValue)) {
|
|
actualValue.forEach(function(item) {
|
|
appendStyle(key, item);
|
|
});
|
|
} else {
|
|
appendStyle(key, actualValue);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
if (!root) {
|
|
styleStr = "{".concat(styleStr, "}");
|
|
} else if (layer) {
|
|
if (styleStr) {
|
|
styleStr = "@layer ".concat(layer.name, " {").concat(styleStr, "}");
|
|
}
|
|
if (layer.dependencies) {
|
|
effectStyle["@layer ".concat(layer.name)] = layer.dependencies.map(function(deps) {
|
|
return "@layer ".concat(deps, ", ").concat(layer.name, ";");
|
|
}).join("\n");
|
|
}
|
|
}
|
|
return [styleStr, effectStyle];
|
|
};
|
|
function uniqueHash(path, styleStr) {
|
|
return hash_browser_esm_default("".concat(path.join("%")).concat(styleStr));
|
|
}
|
|
function Empty() {
|
|
return null;
|
|
}
|
|
var STYLE_PREFIX = "style";
|
|
function useStyleRegister(info, styleFn) {
|
|
var token2 = info.token, path = info.path, hashId = info.hashId, layer = info.layer, nonce = info.nonce, clientOnly = info.clientOnly, _info$order = info.order, order = _info$order === void 0 ? 0 : _info$order;
|
|
var _React$useContext = React6.useContext(StyleContext_default), autoClear = _React$useContext.autoClear, mock = _React$useContext.mock, defaultCache = _React$useContext.defaultCache, hashPriority = _React$useContext.hashPriority, container = _React$useContext.container, ssrInline = _React$useContext.ssrInline, transformers = _React$useContext.transformers, linters = _React$useContext.linters, cache = _React$useContext.cache, enableLayer = _React$useContext.layer;
|
|
var tokenKey = token2._tokenKey;
|
|
var fullPath = [tokenKey];
|
|
if (enableLayer) {
|
|
fullPath.push("layer");
|
|
}
|
|
fullPath.push.apply(fullPath, _toConsumableArray(path));
|
|
var isMergedClientSide = isClientSide;
|
|
if (mock !== void 0) {
|
|
isMergedClientSide = mock === "client";
|
|
}
|
|
var _useGlobalCache = useGlobalCache(
|
|
STYLE_PREFIX,
|
|
fullPath,
|
|
// Create cache if needed
|
|
function() {
|
|
var cachePath = fullPath.join("|");
|
|
if (existPath(cachePath)) {
|
|
var _getStyleAndHash = getStyleAndHash(cachePath), _getStyleAndHash2 = _slicedToArray(_getStyleAndHash, 2), inlineCacheStyleStr = _getStyleAndHash2[0], styleHash = _getStyleAndHash2[1];
|
|
if (inlineCacheStyleStr) {
|
|
return [inlineCacheStyleStr, tokenKey, styleHash, {}, clientOnly, order];
|
|
}
|
|
}
|
|
var styleObj = styleFn();
|
|
var _parseStyle5 = parseStyle(styleObj, {
|
|
hashId,
|
|
hashPriority,
|
|
layer: enableLayer ? layer : void 0,
|
|
path: path.join("-"),
|
|
transformers,
|
|
linters
|
|
}), _parseStyle6 = _slicedToArray(_parseStyle5, 2), parsedStyle = _parseStyle6[0], effectStyle = _parseStyle6[1];
|
|
var styleStr = normalizeStyle(parsedStyle);
|
|
var styleId = uniqueHash(fullPath, styleStr);
|
|
return [styleStr, tokenKey, styleId, effectStyle, clientOnly, order];
|
|
},
|
|
// Remove cache if no need
|
|
function(_ref2, fromHMR) {
|
|
var _ref3 = _slicedToArray(_ref2, 3), styleId = _ref3[2];
|
|
if ((fromHMR || autoClear) && isClientSide) {
|
|
removeCSS(styleId, {
|
|
mark: ATTR_MARK,
|
|
attachTo: container
|
|
});
|
|
}
|
|
},
|
|
// Effect: Inject style here
|
|
function(_ref4) {
|
|
var _ref5 = _slicedToArray(_ref4, 4), styleStr = _ref5[0], _ = _ref5[1], styleId = _ref5[2], effectStyle = _ref5[3];
|
|
if (isMergedClientSide && styleStr !== CSS_FILE_STYLE) {
|
|
var mergedCSSConfig = {
|
|
mark: ATTR_MARK,
|
|
prepend: enableLayer ? false : "queue",
|
|
attachTo: container,
|
|
priority: order
|
|
};
|
|
var nonceStr = typeof nonce === "function" ? nonce() : nonce;
|
|
if (nonceStr) {
|
|
mergedCSSConfig.csp = {
|
|
nonce: nonceStr
|
|
};
|
|
}
|
|
var effectLayerKeys = [];
|
|
var effectRestKeys = [];
|
|
Object.keys(effectStyle).forEach(function(key) {
|
|
if (key.startsWith("@layer")) {
|
|
effectLayerKeys.push(key);
|
|
} else {
|
|
effectRestKeys.push(key);
|
|
}
|
|
});
|
|
effectLayerKeys.forEach(function(effectKey) {
|
|
updateCSS(normalizeStyle(effectStyle[effectKey]), "_layer-".concat(effectKey), _objectSpread2(_objectSpread2({}, mergedCSSConfig), {}, {
|
|
prepend: true
|
|
}));
|
|
});
|
|
var style = updateCSS(styleStr, styleId, mergedCSSConfig);
|
|
style[CSS_IN_JS_INSTANCE] = cache.instanceId;
|
|
style.setAttribute(ATTR_TOKEN, tokenKey);
|
|
if (true) {
|
|
style.setAttribute(ATTR_CACHE_PATH, fullPath.join("|"));
|
|
}
|
|
effectRestKeys.forEach(function(effectKey) {
|
|
updateCSS(normalizeStyle(effectStyle[effectKey]), "_effect-".concat(effectKey), mergedCSSConfig);
|
|
});
|
|
}
|
|
}
|
|
), _useGlobalCache2 = _slicedToArray(_useGlobalCache, 3), cachedStyleStr = _useGlobalCache2[0], cachedTokenKey = _useGlobalCache2[1], cachedStyleId = _useGlobalCache2[2];
|
|
return function(node2) {
|
|
var styleNode;
|
|
if (!ssrInline || isMergedClientSide || !defaultCache) {
|
|
styleNode = React6.createElement(Empty, null);
|
|
} else {
|
|
styleNode = React6.createElement("style", _extends({}, _defineProperty(_defineProperty({}, ATTR_TOKEN, cachedTokenKey), ATTR_MARK, cachedStyleId), {
|
|
dangerouslySetInnerHTML: {
|
|
__html: cachedStyleStr
|
|
}
|
|
}));
|
|
}
|
|
return React6.createElement(React6.Fragment, null, styleNode, node2);
|
|
};
|
|
}
|
|
var extract3 = function extract4(cache, effectStyles, options) {
|
|
var _cache = _slicedToArray(cache, 6), styleStr = _cache[0], tokenKey = _cache[1], styleId = _cache[2], effectStyle = _cache[3], clientOnly = _cache[4], order = _cache[5];
|
|
var _ref7 = options || {}, plain = _ref7.plain;
|
|
if (clientOnly) {
|
|
return null;
|
|
}
|
|
var keyStyleText = styleStr;
|
|
var sharedAttrs = {
|
|
"data-rc-order": "prependQueue",
|
|
"data-rc-priority": "".concat(order)
|
|
};
|
|
keyStyleText = toStyleStr(styleStr, tokenKey, styleId, sharedAttrs, plain);
|
|
if (effectStyle) {
|
|
Object.keys(effectStyle).forEach(function(effectKey) {
|
|
if (!effectStyles[effectKey]) {
|
|
effectStyles[effectKey] = true;
|
|
var effectStyleStr = normalizeStyle(effectStyle[effectKey]);
|
|
var effectStyleHTML = toStyleStr(effectStyleStr, tokenKey, "_effect-".concat(effectKey), sharedAttrs, plain);
|
|
if (effectKey.startsWith("@layer")) {
|
|
keyStyleText = effectStyleHTML + keyStyleText;
|
|
} else {
|
|
keyStyleText += effectStyleHTML;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return [order, styleId, keyStyleText];
|
|
};
|
|
|
|
// node_modules/@ant-design/cssinjs/es/hooks/useCSSVarRegister.js
|
|
var CSS_VAR_PREFIX = "cssVar";
|
|
var useCSSVarRegister = function useCSSVarRegister2(config, fn) {
|
|
var key = config.key, prefix2 = config.prefix, unitless = config.unitless, ignore = config.ignore, token2 = config.token, _config$scope = config.scope, scope = _config$scope === void 0 ? "" : _config$scope;
|
|
var _useContext = (0, import_react2.useContext)(StyleContext_default), instanceId = _useContext.cache.instanceId, container = _useContext.container;
|
|
var tokenKey = token2._tokenKey;
|
|
var stylePath = [].concat(_toConsumableArray(config.path), [key, scope, tokenKey]);
|
|
var cache = useGlobalCache(CSS_VAR_PREFIX, stylePath, function() {
|
|
var originToken = fn();
|
|
var _transformToken = transformToken(originToken, key, {
|
|
prefix: prefix2,
|
|
unitless,
|
|
ignore,
|
|
scope
|
|
}), _transformToken2 = _slicedToArray(_transformToken, 2), mergedToken = _transformToken2[0], cssVarsStr = _transformToken2[1];
|
|
var styleId = uniqueHash(stylePath, cssVarsStr);
|
|
return [mergedToken, cssVarsStr, styleId, key];
|
|
}, function(_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 3), styleId = _ref2[2];
|
|
if (isClientSide) {
|
|
removeCSS(styleId, {
|
|
mark: ATTR_MARK,
|
|
attachTo: container
|
|
});
|
|
}
|
|
}, function(_ref3) {
|
|
var _ref4 = _slicedToArray(_ref3, 3), cssVarsStr = _ref4[1], styleId = _ref4[2];
|
|
if (!cssVarsStr) {
|
|
return;
|
|
}
|
|
var style = updateCSS(cssVarsStr, styleId, {
|
|
mark: ATTR_MARK,
|
|
prepend: "queue",
|
|
attachTo: container,
|
|
priority: -999
|
|
});
|
|
style[CSS_IN_JS_INSTANCE] = instanceId;
|
|
style.setAttribute(ATTR_TOKEN, key);
|
|
});
|
|
return cache;
|
|
};
|
|
var extract5 = function extract6(cache, effectStyles, options) {
|
|
var _cache = _slicedToArray(cache, 4), styleStr = _cache[1], styleId = _cache[2], cssVarKey = _cache[3];
|
|
var _ref5 = options || {}, plain = _ref5.plain;
|
|
if (!styleStr) {
|
|
return null;
|
|
}
|
|
var order = -999;
|
|
var sharedAttrs = {
|
|
"data-rc-order": "prependQueue",
|
|
"data-rc-priority": "".concat(order)
|
|
};
|
|
var styleText = toStyleStr(styleStr, cssVarKey, styleId, sharedAttrs, plain);
|
|
return [order, styleId, styleText];
|
|
};
|
|
var useCSSVarRegister_default = useCSSVarRegister;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/extractStyle.js
|
|
var ExtractStyleFns = _defineProperty(_defineProperty(_defineProperty({}, STYLE_PREFIX, extract3), TOKEN_PREFIX, extract), CSS_VAR_PREFIX, extract5);
|
|
function isNotNull(value) {
|
|
return value !== null;
|
|
}
|
|
function extractStyle(cache, options) {
|
|
var _ref = typeof options === "boolean" ? {
|
|
plain: options
|
|
} : options || {}, _ref$plain = _ref.plain, plain = _ref$plain === void 0 ? false : _ref$plain, _ref$types = _ref.types, types = _ref$types === void 0 ? ["style", "token", "cssVar"] : _ref$types, _ref$once = _ref.once, once = _ref$once === void 0 ? false : _ref$once;
|
|
var matchPrefixRegexp = new RegExp("^(".concat((typeof types === "string" ? [types] : types).join("|"), ")%"));
|
|
var styleKeys = Array.from(cache.cache.keys()).filter(function(key) {
|
|
return matchPrefixRegexp.test(key);
|
|
});
|
|
var effectStyles = {};
|
|
var cachePathMap2 = {};
|
|
var styleText = "";
|
|
styleKeys.map(function(key) {
|
|
if (once && cache.extracted.has(key)) {
|
|
return null;
|
|
}
|
|
var cachePath = key.replace(matchPrefixRegexp, "").replace(/%/g, "|");
|
|
var _key$split = key.split("%"), _key$split2 = _slicedToArray(_key$split, 1), prefix2 = _key$split2[0];
|
|
var extractFn = ExtractStyleFns[prefix2];
|
|
var extractedStyle = extractFn(cache.cache.get(key)[1], effectStyles, {
|
|
plain
|
|
});
|
|
if (!extractedStyle) {
|
|
return null;
|
|
}
|
|
var _extractedStyle = _slicedToArray(extractedStyle, 3), order = _extractedStyle[0], styleId = _extractedStyle[1], styleStr = _extractedStyle[2];
|
|
if (key.startsWith("style")) {
|
|
cachePathMap2[cachePath] = styleId;
|
|
}
|
|
cache.extracted.add(key);
|
|
return [order, styleStr];
|
|
}).filter(isNotNull).sort(function(_ref2, _ref3) {
|
|
var _ref4 = _slicedToArray(_ref2, 1), o1 = _ref4[0];
|
|
var _ref5 = _slicedToArray(_ref3, 1), o2 = _ref5[0];
|
|
return o1 - o2;
|
|
}).forEach(function(_ref6) {
|
|
var _ref7 = _slicedToArray(_ref6, 2), style = _ref7[1];
|
|
styleText += style;
|
|
});
|
|
styleText += toStyleStr(".".concat(ATTR_CACHE_MAP, '{content:"').concat(serialize2(cachePathMap2), '";}'), void 0, void 0, _defineProperty({}, ATTR_CACHE_MAP, ATTR_CACHE_MAP), plain);
|
|
return styleText;
|
|
}
|
|
|
|
// node_modules/@ant-design/cssinjs/es/Keyframes.js
|
|
init_defineProperty();
|
|
var Keyframe = (function() {
|
|
function Keyframe2(name, style) {
|
|
_classCallCheck(this, Keyframe2);
|
|
_defineProperty(this, "name", void 0);
|
|
_defineProperty(this, "style", void 0);
|
|
_defineProperty(this, "_keyframe", true);
|
|
this.name = name;
|
|
this.style = style;
|
|
}
|
|
_createClass(Keyframe2, [{
|
|
key: "getName",
|
|
value: function getName() {
|
|
var hashId = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
|
|
return hashId ? "".concat(hashId, "-").concat(this.name) : this.name;
|
|
}
|
|
}]);
|
|
return Keyframe2;
|
|
})();
|
|
var Keyframes_default = Keyframe;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/transformers/legacyLogicalProperties.js
|
|
function splitValues(value) {
|
|
if (typeof value === "number") {
|
|
return [[value], false];
|
|
}
|
|
var rawStyle = String(value).trim();
|
|
var importantCells = rawStyle.match(/(.*)(!important)/);
|
|
var splitStyle = (importantCells ? importantCells[1] : rawStyle).trim().split(/\s+/);
|
|
var temp = [];
|
|
var brackets = 0;
|
|
return [splitStyle.reduce(function(list, item) {
|
|
if (item.includes("(") || item.includes(")")) {
|
|
var left = item.split("(").length - 1;
|
|
var right = item.split(")").length - 1;
|
|
brackets += left - right;
|
|
}
|
|
if (brackets >= 0) temp.push(item);
|
|
if (brackets === 0) {
|
|
list.push(temp.join(" "));
|
|
temp = [];
|
|
}
|
|
return list;
|
|
}, []), !!importantCells];
|
|
}
|
|
function noSplit(list) {
|
|
list.notSplit = true;
|
|
return list;
|
|
}
|
|
var keyMap = {
|
|
// Inset
|
|
inset: ["top", "right", "bottom", "left"],
|
|
insetBlock: ["top", "bottom"],
|
|
insetBlockStart: ["top"],
|
|
insetBlockEnd: ["bottom"],
|
|
insetInline: ["left", "right"],
|
|
insetInlineStart: ["left"],
|
|
insetInlineEnd: ["right"],
|
|
// Margin
|
|
marginBlock: ["marginTop", "marginBottom"],
|
|
marginBlockStart: ["marginTop"],
|
|
marginBlockEnd: ["marginBottom"],
|
|
marginInline: ["marginLeft", "marginRight"],
|
|
marginInlineStart: ["marginLeft"],
|
|
marginInlineEnd: ["marginRight"],
|
|
// Padding
|
|
paddingBlock: ["paddingTop", "paddingBottom"],
|
|
paddingBlockStart: ["paddingTop"],
|
|
paddingBlockEnd: ["paddingBottom"],
|
|
paddingInline: ["paddingLeft", "paddingRight"],
|
|
paddingInlineStart: ["paddingLeft"],
|
|
paddingInlineEnd: ["paddingRight"],
|
|
// Border
|
|
borderBlock: noSplit(["borderTop", "borderBottom"]),
|
|
borderBlockStart: noSplit(["borderTop"]),
|
|
borderBlockEnd: noSplit(["borderBottom"]),
|
|
borderInline: noSplit(["borderLeft", "borderRight"]),
|
|
borderInlineStart: noSplit(["borderLeft"]),
|
|
borderInlineEnd: noSplit(["borderRight"]),
|
|
// Border width
|
|
borderBlockWidth: ["borderTopWidth", "borderBottomWidth"],
|
|
borderBlockStartWidth: ["borderTopWidth"],
|
|
borderBlockEndWidth: ["borderBottomWidth"],
|
|
borderInlineWidth: ["borderLeftWidth", "borderRightWidth"],
|
|
borderInlineStartWidth: ["borderLeftWidth"],
|
|
borderInlineEndWidth: ["borderRightWidth"],
|
|
// Border style
|
|
borderBlockStyle: ["borderTopStyle", "borderBottomStyle"],
|
|
borderBlockStartStyle: ["borderTopStyle"],
|
|
borderBlockEndStyle: ["borderBottomStyle"],
|
|
borderInlineStyle: ["borderLeftStyle", "borderRightStyle"],
|
|
borderInlineStartStyle: ["borderLeftStyle"],
|
|
borderInlineEndStyle: ["borderRightStyle"],
|
|
// Border color
|
|
borderBlockColor: ["borderTopColor", "borderBottomColor"],
|
|
borderBlockStartColor: ["borderTopColor"],
|
|
borderBlockEndColor: ["borderBottomColor"],
|
|
borderInlineColor: ["borderLeftColor", "borderRightColor"],
|
|
borderInlineStartColor: ["borderLeftColor"],
|
|
borderInlineEndColor: ["borderRightColor"],
|
|
// Border radius
|
|
borderStartStartRadius: ["borderTopLeftRadius"],
|
|
borderStartEndRadius: ["borderTopRightRadius"],
|
|
borderEndStartRadius: ["borderBottomLeftRadius"],
|
|
borderEndEndRadius: ["borderBottomRightRadius"]
|
|
};
|
|
function wrapImportantAndSkipCheck(value, important) {
|
|
var parsedValue = value;
|
|
if (important) {
|
|
parsedValue = "".concat(parsedValue, " !important");
|
|
}
|
|
return {
|
|
_skip_check_: true,
|
|
value: parsedValue
|
|
};
|
|
}
|
|
var transform = {
|
|
visit: function visit(cssObj) {
|
|
var clone = {};
|
|
Object.keys(cssObj).forEach(function(key) {
|
|
var value = cssObj[key];
|
|
var matchValue = keyMap[key];
|
|
if (matchValue && (typeof value === "number" || typeof value === "string")) {
|
|
var _splitValues = splitValues(value), _splitValues2 = _slicedToArray(_splitValues, 2), _values = _splitValues2[0], _important = _splitValues2[1];
|
|
if (matchValue.length && matchValue.notSplit) {
|
|
matchValue.forEach(function(matchKey) {
|
|
clone[matchKey] = wrapImportantAndSkipCheck(value, _important);
|
|
});
|
|
} else if (matchValue.length === 1) {
|
|
clone[matchValue[0]] = wrapImportantAndSkipCheck(_values[0], _important);
|
|
} else if (matchValue.length === 2) {
|
|
matchValue.forEach(function(matchKey, index) {
|
|
var _values$index;
|
|
clone[matchKey] = wrapImportantAndSkipCheck((_values$index = _values[index]) !== null && _values$index !== void 0 ? _values$index : _values[0], _important);
|
|
});
|
|
} else if (matchValue.length === 4) {
|
|
matchValue.forEach(function(matchKey, index) {
|
|
var _ref, _values$index2;
|
|
clone[matchKey] = wrapImportantAndSkipCheck((_ref = (_values$index2 = _values[index]) !== null && _values$index2 !== void 0 ? _values$index2 : _values[index - 2]) !== null && _ref !== void 0 ? _ref : _values[0], _important);
|
|
});
|
|
} else {
|
|
clone[key] = value;
|
|
}
|
|
} else {
|
|
clone[key] = value;
|
|
}
|
|
});
|
|
return clone;
|
|
}
|
|
};
|
|
var legacyLogicalProperties_default = transform;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/transformers/px2rem.js
|
|
var pxRegex = /url\([^)]+\)|var\([^)]+\)|(\d*\.?\d+)px/g;
|
|
function toFixed(number, precision) {
|
|
var multiplier = Math.pow(10, precision + 1), wholeNumber = Math.floor(number * multiplier);
|
|
return Math.round(wholeNumber / 10) * 10 / multiplier;
|
|
}
|
|
var transform2 = function transform3() {
|
|
var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
var _options$rootValue = options.rootValue, rootValue = _options$rootValue === void 0 ? 16 : _options$rootValue, _options$precision = options.precision, precision = _options$precision === void 0 ? 5 : _options$precision, _options$mediaQuery = options.mediaQuery, mediaQuery = _options$mediaQuery === void 0 ? false : _options$mediaQuery;
|
|
var pxReplace = function pxReplace2(m, $1) {
|
|
if (!$1) return m;
|
|
var pixels = parseFloat($1);
|
|
if (pixels <= 1) return m;
|
|
var fixedVal = toFixed(pixels / rootValue, precision);
|
|
return "".concat(fixedVal, "rem");
|
|
};
|
|
var visit2 = function visit3(cssObj) {
|
|
var clone = _objectSpread2({}, cssObj);
|
|
Object.entries(cssObj).forEach(function(_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1];
|
|
if (typeof value === "string" && value.includes("px")) {
|
|
var newValue = value.replace(pxRegex, pxReplace);
|
|
clone[key] = newValue;
|
|
}
|
|
if (!unitless_browser_esm_default[key] && typeof value === "number" && value !== 0) {
|
|
clone[key] = "".concat(value, "px").replace(pxRegex, pxReplace);
|
|
}
|
|
var mergedKey = key.trim();
|
|
if (mergedKey.startsWith("@") && mergedKey.includes("px") && mediaQuery) {
|
|
var newKey = key.replace(pxRegex, pxReplace);
|
|
clone[newKey] = clone[key];
|
|
delete clone[key];
|
|
}
|
|
});
|
|
return clone;
|
|
};
|
|
return {
|
|
visit: visit2
|
|
};
|
|
};
|
|
var px2rem_default = transform2;
|
|
|
|
// node_modules/@ant-design/cssinjs/es/index.js
|
|
var _experimental = {
|
|
supportModernCSS: function supportModernCSS() {
|
|
return supportWhere() && supportLogicProps();
|
|
}
|
|
};
|
|
|
|
export {
|
|
_iterableToArray,
|
|
_toConsumableArray,
|
|
isEqual_default,
|
|
_classCallCheck,
|
|
_createClass,
|
|
createCache,
|
|
StyleProvider,
|
|
StyleContext_default,
|
|
_inherits,
|
|
_getPrototypeOf,
|
|
_isNativeReflectConstruct,
|
|
_possibleConstructorReturn,
|
|
_createSuper,
|
|
calc_default,
|
|
Theme,
|
|
createTheme,
|
|
unit2 as unit,
|
|
token2CSSVar,
|
|
useLayoutUpdateEffect,
|
|
useLayoutEffect_default,
|
|
getComputedToken,
|
|
useCacheToken,
|
|
legacyNotSelectorLinter_default,
|
|
logicalPropertiesLinter_default,
|
|
NaNLinter_default,
|
|
parentSelectorLinter_default,
|
|
useStyleRegister,
|
|
useCSSVarRegister_default,
|
|
extractStyle,
|
|
Keyframes_default,
|
|
legacyLogicalProperties_default,
|
|
px2rem_default,
|
|
_experimental
|
|
};
|
|
//# sourceMappingURL=chunk-DINYHDVU.js.map
|