(self["webpackChunk"] = self["webpackChunk"] || []).push([[78830,47897],{ /***/ 47897: /*!***********************************************************!*\ !*** ./node_modules/antd/es/switch/index.js + 27 modules ***! \***********************************************************/ /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { "use strict"; // EXPORTS __webpack_require__.d(__webpack_exports__, { "Z": function() { return /* binding */ es_switch; } }); // EXTERNAL MODULE: ./node_modules/@ant-design/icons/es/icons/LoadingOutlined.js + 1 modules var LoadingOutlined = __webpack_require__(50888); // EXTERNAL MODULE: ./node_modules/classnames/index.js var classnames = __webpack_require__(94184); var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames); ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/extends.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); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/typeof.js function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/toPrimitive.js function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/defineProperty.js function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/slicedToArray.js function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } // EXTERNAL MODULE: ./node_modules/react/index.js var react = __webpack_require__(67294); ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js function arrayWithHoles_arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js function iterableToArrayLimit_iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js function arrayLikeToArray_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js function unsupportedIterableToArray_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return arrayLikeToArray_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray_arrayLikeToArray(o, minLen); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js function nonIterableRest_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/node_modules/@babel/runtime/helpers/esm/slicedToArray.js function slicedToArray_slicedToArray(arr, i) { return arrayWithHoles_arrayWithHoles(arr) || iterableToArrayLimit_iterableToArrayLimit(arr, i) || unsupportedIterableToArray_unsupportedIterableToArray(arr, i) || nonIterableRest_nonIterableRest(); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/es/hooks/useEvent.js function useEvent(callback) { var fnRef = react.useRef(); fnRef.current = callback; var memoFn = react.useCallback(function () { var _fnRef$current; for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } return (_fnRef$current = fnRef.current) === null || _fnRef$current === void 0 ? void 0 : _fnRef$current.call.apply(_fnRef$current, [fnRef].concat(args)); }, []); return memoFn; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/es/Dom/canUseDom.js function canUseDom() { return !!(typeof window !== 'undefined' && window.document && window.document.createElement); } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/es/hooks/useLayoutEffect.js /** * Wrap `React.useLayoutEffect` which will not throw warning message in test env */ var useInternalLayoutEffect = true && canUseDom() ? react.useLayoutEffect : react.useEffect; var useLayoutEffect = function useLayoutEffect(callback, deps) { var firstMountRef = react.useRef(true); useInternalLayoutEffect(function () { return callback(firstMountRef.current); }, deps); // We tell react that first mount has passed useInternalLayoutEffect(function () { firstMountRef.current = false; return function () { firstMountRef.current = true; }; }, []); }; var useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) { useLayoutEffect(function (firstMount) { if (!firstMount) { return callback(); } }, deps); }; /* harmony default export */ var hooks_useLayoutEffect = ((/* unused pure expression or super */ null && (useLayoutEffect))); ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/es/hooks/useState.js /** * Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed. * We do not make this auto is to avoid real memory leak. * Developer should confirm it's safe to ignore themselves. */ function useSafeState(defaultValue) { var destroyRef = react.useRef(false); var _React$useState = react.useState(defaultValue), _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2), value = _React$useState2[0], setValue = _React$useState2[1]; react.useEffect(function () { destroyRef.current = false; return function () { destroyRef.current = true; }; }, []); function safeSetState(updater, ignoreDestroy) { if (ignoreDestroy && destroyRef.current) { return; } setValue(updater); } return [value, safeSetState]; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/es/hooks/useMergedState.js /** We only think `undefined` is empty */ function hasValue(value) { return value !== undefined; } /** * Similar to `useState` but will use props value if provided. * Note that internal use rc-util `useState` hook. */ function useMergedState(defaultStateValue, option) { var _ref = option || {}, defaultValue = _ref.defaultValue, value = _ref.value, onChange = _ref.onChange, postState = _ref.postState; // ======================= Init ======================= var _useState = useSafeState(function () { if (hasValue(value)) { return value; } else if (hasValue(defaultValue)) { return typeof defaultValue === 'function' ? defaultValue() : defaultValue; } else { return typeof defaultStateValue === 'function' ? defaultStateValue() : defaultStateValue; } }), _useState2 = slicedToArray_slicedToArray(_useState, 2), innerValue = _useState2[0], setInnerValue = _useState2[1]; var mergedValue = value !== undefined ? value : innerValue; var postMergedValue = postState ? postState(mergedValue) : mergedValue; // ====================== Change ====================== var onChangeFn = useEvent(onChange); var _useState3 = useSafeState([mergedValue]), _useState4 = slicedToArray_slicedToArray(_useState3, 2), prevValue = _useState4[0], setPrevValue = _useState4[1]; useLayoutUpdateEffect(function () { var prev = prevValue[0]; if (innerValue !== prev) { onChangeFn(innerValue, prev); } }, [prevValue]); // Sync value back to `undefined` when it from control to un-control useLayoutUpdateEffect(function () { if (!hasValue(value)) { setInnerValue(value); } }, [value]); // ====================== Update ====================== var triggerChange = useEvent(function (updater, ignoreDestroy) { setInnerValue(updater, ignoreDestroy); setPrevValue([mergedValue], ignoreDestroy); }); return [postMergedValue, triggerChange]; } ;// CONCATENATED MODULE: ./node_modules/rc-switch/node_modules/rc-util/es/KeyCode.js /** * @ignore * some key-codes definition and utils from closure-library * @author yiminghe@gmail.com */ var KeyCode = { /** * MAC_ENTER */ MAC_ENTER: 3, /** * BACKSPACE */ BACKSPACE: 8, /** * TAB */ TAB: 9, /** * NUMLOCK on FF/Safari Mac */ NUM_CENTER: 12, // NUMLOCK on FF/Safari Mac /** * ENTER */ ENTER: 13, /** * SHIFT */ SHIFT: 16, /** * CTRL */ CTRL: 17, /** * ALT */ ALT: 18, /** * PAUSE */ PAUSE: 19, /** * CAPS_LOCK */ CAPS_LOCK: 20, /** * ESC */ ESC: 27, /** * SPACE */ SPACE: 32, /** * PAGE_UP */ PAGE_UP: 33, // also NUM_NORTH_EAST /** * PAGE_DOWN */ PAGE_DOWN: 34, // also NUM_SOUTH_EAST /** * END */ END: 35, // also NUM_SOUTH_WEST /** * HOME */ HOME: 36, // also NUM_NORTH_WEST /** * LEFT */ LEFT: 37, // also NUM_WEST /** * UP */ UP: 38, // also NUM_NORTH /** * RIGHT */ RIGHT: 39, // also NUM_EAST /** * DOWN */ DOWN: 40, // also NUM_SOUTH /** * PRINT_SCREEN */ PRINT_SCREEN: 44, /** * INSERT */ INSERT: 45, // also NUM_INSERT /** * DELETE */ DELETE: 46, // also NUM_DELETE /** * ZERO */ ZERO: 48, /** * ONE */ ONE: 49, /** * TWO */ TWO: 50, /** * THREE */ THREE: 51, /** * FOUR */ FOUR: 52, /** * FIVE */ FIVE: 53, /** * SIX */ SIX: 54, /** * SEVEN */ SEVEN: 55, /** * EIGHT */ EIGHT: 56, /** * NINE */ NINE: 57, /** * QUESTION_MARK */ QUESTION_MARK: 63, // needs localization /** * A */ A: 65, /** * B */ B: 66, /** * C */ C: 67, /** * D */ D: 68, /** * E */ E: 69, /** * F */ F: 70, /** * G */ G: 71, /** * H */ H: 72, /** * I */ I: 73, /** * J */ J: 74, /** * K */ K: 75, /** * L */ L: 76, /** * M */ M: 77, /** * N */ N: 78, /** * O */ O: 79, /** * P */ P: 80, /** * Q */ Q: 81, /** * R */ R: 82, /** * S */ S: 83, /** * T */ T: 84, /** * U */ U: 85, /** * V */ V: 86, /** * W */ W: 87, /** * X */ X: 88, /** * Y */ Y: 89, /** * Z */ Z: 90, /** * META */ META: 91, // WIN_KEY_LEFT /** * WIN_KEY_RIGHT */ WIN_KEY_RIGHT: 92, /** * CONTEXT_MENU */ CONTEXT_MENU: 93, /** * NUM_ZERO */ NUM_ZERO: 96, /** * NUM_ONE */ NUM_ONE: 97, /** * NUM_TWO */ NUM_TWO: 98, /** * NUM_THREE */ NUM_THREE: 99, /** * NUM_FOUR */ NUM_FOUR: 100, /** * NUM_FIVE */ NUM_FIVE: 101, /** * NUM_SIX */ NUM_SIX: 102, /** * NUM_SEVEN */ NUM_SEVEN: 103, /** * NUM_EIGHT */ NUM_EIGHT: 104, /** * NUM_NINE */ NUM_NINE: 105, /** * NUM_MULTIPLY */ NUM_MULTIPLY: 106, /** * NUM_PLUS */ NUM_PLUS: 107, /** * NUM_MINUS */ NUM_MINUS: 109, /** * NUM_PERIOD */ NUM_PERIOD: 110, /** * NUM_DIVISION */ NUM_DIVISION: 111, /** * F1 */ F1: 112, /** * F2 */ F2: 113, /** * F3 */ F3: 114, /** * F4 */ F4: 115, /** * F5 */ F5: 116, /** * F6 */ F6: 117, /** * F7 */ F7: 118, /** * F8 */ F8: 119, /** * F9 */ F9: 120, /** * F10 */ F10: 121, /** * F11 */ F11: 122, /** * F12 */ F12: 123, /** * NUMLOCK */ NUMLOCK: 144, /** * SEMICOLON */ SEMICOLON: 186, // needs localization /** * DASH */ DASH: 189, // needs localization /** * EQUALS */ EQUALS: 187, // needs localization /** * COMMA */ COMMA: 188, // needs localization /** * PERIOD */ PERIOD: 190, // needs localization /** * SLASH */ SLASH: 191, // needs localization /** * APOSTROPHE */ APOSTROPHE: 192, // needs localization /** * SINGLE_QUOTE */ SINGLE_QUOTE: 222, // needs localization /** * OPEN_SQUARE_BRACKET */ OPEN_SQUARE_BRACKET: 219, // needs localization /** * BACKSLASH */ BACKSLASH: 220, // needs localization /** * CLOSE_SQUARE_BRACKET */ CLOSE_SQUARE_BRACKET: 221, // needs localization /** * WIN_KEY */ WIN_KEY: 224, /** * MAC_FF_META */ MAC_FF_META: 224, // Firefox (Gecko) fires this for the meta key instead of 91 /** * WIN_IME */ WIN_IME: 229, // ======================== Function ======================== /** * whether text and modified key is entered at the same time. */ isTextModifyingKeyEvent: function isTextModifyingKeyEvent(e) { var keyCode = e.keyCode; if (e.altKey && !e.ctrlKey || e.metaKey || // Function keys don't generate text keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) { return false; } // The following keys are quite harmless, even in combination with // CTRL, ALT or SHIFT. switch (keyCode) { case KeyCode.ALT: case KeyCode.CAPS_LOCK: case KeyCode.CONTEXT_MENU: case KeyCode.CTRL: case KeyCode.DOWN: case KeyCode.END: case KeyCode.ESC: case KeyCode.HOME: case KeyCode.INSERT: case KeyCode.LEFT: case KeyCode.MAC_FF_META: case KeyCode.META: case KeyCode.NUMLOCK: case KeyCode.NUM_CENTER: case KeyCode.PAGE_DOWN: case KeyCode.PAGE_UP: case KeyCode.PAUSE: case KeyCode.PRINT_SCREEN: case KeyCode.RIGHT: case KeyCode.SHIFT: case KeyCode.UP: case KeyCode.WIN_KEY: case KeyCode.WIN_KEY_RIGHT: return false; default: return true; } }, /** * whether character is entered. */ isCharacterKey: function isCharacterKey(keyCode) { if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) { return true; } if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) { return true; } if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) { return true; } // Safari sends zero key code for non-latin characters. if (window.navigator.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) { return true; } switch (keyCode) { case KeyCode.SPACE: case KeyCode.QUESTION_MARK: case KeyCode.NUM_PLUS: case KeyCode.NUM_MINUS: case KeyCode.NUM_PERIOD: case KeyCode.NUM_DIVISION: case KeyCode.SEMICOLON: case KeyCode.DASH: case KeyCode.EQUALS: case KeyCode.COMMA: case KeyCode.PERIOD: case KeyCode.SLASH: case KeyCode.APOSTROPHE: case KeyCode.SINGLE_QUOTE: case KeyCode.OPEN_SQUARE_BRACKET: case KeyCode.BACKSLASH: case KeyCode.CLOSE_SQUARE_BRACKET: return true; default: return false; } } }; /* harmony default export */ var es_KeyCode = (KeyCode); ;// CONCATENATED MODULE: ./node_modules/rc-switch/es/index.js var _excluded = ["prefixCls", "className", "checked", "defaultChecked", "disabled", "loadingIcon", "checkedChildren", "unCheckedChildren", "onClick", "onChange", "onKeyDown"]; var Switch = /*#__PURE__*/react.forwardRef(function (_ref, ref) { var _classNames; var _ref$prefixCls = _ref.prefixCls, prefixCls = _ref$prefixCls === void 0 ? 'rc-switch' : _ref$prefixCls, className = _ref.className, checked = _ref.checked, defaultChecked = _ref.defaultChecked, disabled = _ref.disabled, loadingIcon = _ref.loadingIcon, checkedChildren = _ref.checkedChildren, unCheckedChildren = _ref.unCheckedChildren, onClick = _ref.onClick, onChange = _ref.onChange, onKeyDown = _ref.onKeyDown, restProps = _objectWithoutProperties(_ref, _excluded); var _useMergedState = useMergedState(false, { value: checked, defaultValue: defaultChecked }), _useMergedState2 = _slicedToArray(_useMergedState, 2), innerChecked = _useMergedState2[0], setInnerChecked = _useMergedState2[1]; function triggerChange(newChecked, event) { var mergedChecked = innerChecked; if (!disabled) { mergedChecked = newChecked; setInnerChecked(mergedChecked); onChange === null || onChange === void 0 ? void 0 : onChange(mergedChecked, event); } return mergedChecked; } function onInternalKeyDown(e) { if (e.which === es_KeyCode.LEFT) { triggerChange(false, e); } else if (e.which === es_KeyCode.RIGHT) { triggerChange(true, e); } onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(e); } function onInternalClick(e) { var ret = triggerChange(!innerChecked, e); // [Legacy] trigger onClick with value onClick === null || onClick === void 0 ? void 0 : onClick(ret, e); } var switchClassName = classnames_default()(prefixCls, className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-checked"), innerChecked), _defineProperty(_classNames, "".concat(prefixCls, "-disabled"), disabled), _classNames)); return /*#__PURE__*/react.createElement("button", _extends({}, restProps, { type: "button", role: "switch", "aria-checked": innerChecked, disabled: disabled, className: switchClassName, ref: ref, onKeyDown: onInternalKeyDown, onClick: onInternalClick }), loadingIcon, /*#__PURE__*/react.createElement("span", { className: "".concat(prefixCls, "-inner") }, /*#__PURE__*/react.createElement("span", { className: "".concat(prefixCls, "-inner-checked") }, checkedChildren), /*#__PURE__*/react.createElement("span", { className: "".concat(prefixCls, "-inner-unchecked") }, unCheckedChildren))); }); Switch.displayName = 'Switch'; /* harmony default export */ var es = (Switch); // EXTERNAL MODULE: ./node_modules/antd/es/_util/wave/index.js + 4 modules var wave = __webpack_require__(45353); // EXTERNAL MODULE: ./node_modules/antd/es/config-provider/context.js var context = __webpack_require__(53124); // EXTERNAL MODULE: ./node_modules/antd/es/config-provider/DisabledContext.js var DisabledContext = __webpack_require__(98866); // EXTERNAL MODULE: ./node_modules/antd/es/config-provider/hooks/useSize.js var useSize = __webpack_require__(98675); // EXTERNAL MODULE: ./node_modules/@ctrl/tinycolor/dist/module/index.js var dist_module = __webpack_require__(10274); // EXTERNAL MODULE: ./node_modules/antd/es/style/index.js var style = __webpack_require__(14747); // EXTERNAL MODULE: ./node_modules/antd/es/theme/util/genComponentStyleHook.js var genComponentStyleHook = __webpack_require__(67968); // EXTERNAL MODULE: ./node_modules/antd/es/theme/util/statistic.js var statistic = __webpack_require__(45503); ;// CONCATENATED MODULE: ./node_modules/antd/es/switch/style/index.js const genSwitchSmallStyle = token => { const { componentCls } = token; const switchInnerCls = `${componentCls}-inner`; return { [componentCls]: { [`&${componentCls}-small`]: { minWidth: token.switchMinWidthSM, height: token.switchHeightSM, lineHeight: `${token.switchHeightSM}px`, [`${componentCls}-inner`]: { paddingInlineStart: token.switchInnerMarginMaxSM, paddingInlineEnd: token.switchInnerMarginMinSM, [`${switchInnerCls}-checked`]: { marginInlineStart: `calc(-100% + ${token.switchPinSizeSM + token.switchPadding * 2}px - ${token.switchInnerMarginMaxSM * 2}px)`, marginInlineEnd: `calc(100% - ${token.switchPinSizeSM + token.switchPadding * 2}px + ${token.switchInnerMarginMaxSM * 2}px)` }, [`${switchInnerCls}-unchecked`]: { marginTop: -token.switchHeightSM, marginInlineStart: 0, marginInlineEnd: 0 } }, [`${componentCls}-handle`]: { width: token.switchPinSizeSM, height: token.switchPinSizeSM }, [`${componentCls}-loading-icon`]: { top: (token.switchPinSizeSM - token.switchLoadingIconSize) / 2, fontSize: token.switchLoadingIconSize }, [`&${componentCls}-checked`]: { [`${componentCls}-inner`]: { paddingInlineStart: token.switchInnerMarginMinSM, paddingInlineEnd: token.switchInnerMarginMaxSM, [`${switchInnerCls}-checked`]: { marginInlineStart: 0, marginInlineEnd: 0 }, [`${switchInnerCls}-unchecked`]: { marginInlineStart: `calc(100% - ${token.switchPinSizeSM + token.switchPadding * 2}px + ${token.switchInnerMarginMaxSM * 2}px)`, marginInlineEnd: `calc(-100% + ${token.switchPinSizeSM + token.switchPadding * 2}px - ${token.switchInnerMarginMaxSM * 2}px)` } }, [`${componentCls}-handle`]: { insetInlineStart: `calc(100% - ${token.switchPinSizeSM + token.switchPadding}px)` } }, [`&:not(${componentCls}-disabled):active`]: { [`&:not(${componentCls}-checked) ${switchInnerCls}`]: { [`${switchInnerCls}-unchecked`]: { marginInlineStart: token.marginXXS / 2, marginInlineEnd: -token.marginXXS / 2 } }, [`&${componentCls}-checked ${switchInnerCls}`]: { [`${switchInnerCls}-checked`]: { marginInlineStart: -token.marginXXS / 2, marginInlineEnd: token.marginXXS / 2 } } } } } }; }; const genSwitchLoadingStyle = token => { const { componentCls } = token; return { [componentCls]: { [`${componentCls}-loading-icon${token.iconCls}`]: { position: 'relative', top: (token.switchPinSize - token.fontSize) / 2, color: token.switchLoadingIconColor, verticalAlign: 'top' }, [`&${componentCls}-checked ${componentCls}-loading-icon`]: { color: token.switchColor } } }; }; const genSwitchHandleStyle = token => { const { componentCls, motion } = token; const switchHandleCls = `${componentCls}-handle`; return { [componentCls]: { [switchHandleCls]: { position: 'absolute', top: token.switchPadding, insetInlineStart: token.switchPadding, width: token.switchPinSize, height: token.switchPinSize, transition: `all ${token.switchDuration} ease-in-out`, '&::before': { position: 'absolute', top: 0, insetInlineEnd: 0, bottom: 0, insetInlineStart: 0, backgroundColor: token.colorWhite, borderRadius: token.switchPinSize / 2, boxShadow: token.switchHandleShadow, transition: `all ${token.switchDuration} ease-in-out`, content: '""' } }, [`&${componentCls}-checked ${switchHandleCls}`]: { insetInlineStart: `calc(100% - ${token.switchPinSize + token.switchPadding}px)` }, [`&:not(${componentCls}-disabled):active`]: motion ? { [`${switchHandleCls}::before`]: { insetInlineEnd: token.switchHandleActiveInset, insetInlineStart: 0 }, [`&${componentCls}-checked ${switchHandleCls}::before`]: { insetInlineEnd: 0, insetInlineStart: token.switchHandleActiveInset } } : /* istanbul ignore next */ {} } }; }; const genSwitchInnerStyle = token => { const { componentCls } = token; const switchInnerCls = `${componentCls}-inner`; return { [componentCls]: { [switchInnerCls]: { display: 'block', overflow: 'hidden', borderRadius: 100, height: '100%', paddingInlineStart: token.switchInnerMarginMax, paddingInlineEnd: token.switchInnerMarginMin, transition: `padding-inline-start ${token.switchDuration} ease-in-out, padding-inline-end ${token.switchDuration} ease-in-out`, [`${switchInnerCls}-checked, ${switchInnerCls}-unchecked`]: { display: 'block', color: token.colorTextLightSolid, fontSize: token.fontSizeSM, transition: `margin-inline-start ${token.switchDuration} ease-in-out, margin-inline-end ${token.switchDuration} ease-in-out`, pointerEvents: 'none' }, [`${switchInnerCls}-checked`]: { marginInlineStart: `calc(-100% + ${token.switchPinSize + token.switchPadding * 2}px - ${token.switchInnerMarginMax * 2}px)`, marginInlineEnd: `calc(100% - ${token.switchPinSize + token.switchPadding * 2}px + ${token.switchInnerMarginMax * 2}px)` }, [`${switchInnerCls}-unchecked`]: { marginTop: -token.switchHeight, marginInlineStart: 0, marginInlineEnd: 0 } }, [`&${componentCls}-checked ${switchInnerCls}`]: { paddingInlineStart: token.switchInnerMarginMin, paddingInlineEnd: token.switchInnerMarginMax, [`${switchInnerCls}-checked`]: { marginInlineStart: 0, marginInlineEnd: 0 }, [`${switchInnerCls}-unchecked`]: { marginInlineStart: `calc(100% - ${token.switchPinSize + token.switchPadding * 2}px + ${token.switchInnerMarginMax * 2}px)`, marginInlineEnd: `calc(-100% + ${token.switchPinSize + token.switchPadding * 2}px - ${token.switchInnerMarginMax * 2}px)` } }, [`&:not(${componentCls}-disabled):active`]: { [`&:not(${componentCls}-checked) ${switchInnerCls}`]: { [`${switchInnerCls}-unchecked`]: { marginInlineStart: token.switchPadding * 2, marginInlineEnd: -token.switchPadding * 2 } }, [`&${componentCls}-checked ${switchInnerCls}`]: { [`${switchInnerCls}-checked`]: { marginInlineStart: -token.switchPadding * 2, marginInlineEnd: token.switchPadding * 2 } } } } }; }; const genSwitchStyle = token => { const { componentCls } = token; return { [componentCls]: Object.assign(Object.assign(Object.assign(Object.assign({}, (0,style/* resetComponent */.Wf)(token)), { position: 'relative', display: 'inline-block', boxSizing: 'border-box', minWidth: token.switchMinWidth, height: token.switchHeight, lineHeight: `${token.switchHeight}px`, verticalAlign: 'middle', background: token.colorTextQuaternary, border: '0', borderRadius: 100, cursor: 'pointer', transition: `all ${token.motionDurationMid}`, userSelect: 'none', [`&:hover:not(${componentCls}-disabled)`]: { background: token.colorTextTertiary } }), (0,style/* genFocusStyle */.Qy)(token)), { [`&${componentCls}-checked`]: { background: token.switchColor, [`&:hover:not(${componentCls}-disabled)`]: { background: token.colorPrimaryHover } }, [`&${componentCls}-loading, &${componentCls}-disabled`]: { cursor: 'not-allowed', opacity: token.switchDisabledOpacity, '*': { boxShadow: 'none', cursor: 'not-allowed' } }, // rtl style [`&${componentCls}-rtl`]: { direction: 'rtl' } }) }; }; // ============================== Export ============================== /* harmony default export */ var switch_style = ((0,genComponentStyleHook/* default */.Z)('Switch', token => { const switchHeight = token.fontSize * token.lineHeight; const switchHeightSM = token.controlHeight / 2; const switchPadding = 2; // This is magic const switchPinSize = switchHeight - switchPadding * 2; const switchPinSizeSM = switchHeightSM - switchPadding * 2; const switchToken = (0,statistic/* merge */.TS)(token, { switchMinWidth: switchPinSize * 2 + switchPadding * 4, switchHeight, switchDuration: token.motionDurationMid, switchColor: token.colorPrimary, switchDisabledOpacity: token.opacityLoading, switchInnerMarginMin: switchPinSize / 2, switchInnerMarginMax: switchPinSize + switchPadding + switchPadding * 2, switchPadding, switchPinSize, switchBg: token.colorBgContainer, switchMinWidthSM: switchPinSizeSM * 2 + switchPadding * 2, switchHeightSM, switchInnerMarginMinSM: switchPinSizeSM / 2, switchInnerMarginMaxSM: switchPinSizeSM + switchPadding + switchPadding * 2, switchPinSizeSM, switchHandleShadow: `0 2px 4px 0 ${new dist_module/* TinyColor */.C('#00230b').setAlpha(0.2).toRgbString()}`, switchLoadingIconSize: token.fontSizeIcon * 0.75, switchLoadingIconColor: `rgba(0, 0, 0, ${token.opacityLoading})`, switchHandleActiveInset: '-30%' }); return [genSwitchStyle(switchToken), // inner style genSwitchInnerStyle(switchToken), // handle style genSwitchHandleStyle(switchToken), // loading style genSwitchLoadingStyle(switchToken), // small style genSwitchSmallStyle(switchToken)]; })); ;// CONCATENATED MODULE: ./node_modules/antd/es/switch/index.js 'use client'; var __rest = undefined && undefined.__rest || function (s, e) { var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; } return t; }; const switch_Switch = /*#__PURE__*/react.forwardRef((props, ref) => { const { prefixCls: customizePrefixCls, size: customizeSize, disabled: customDisabled, loading, className, rootClassName, style } = props, restProps = __rest(props, ["prefixCls", "size", "disabled", "loading", "className", "rootClassName", "style"]); false ? 0 : void 0; const { getPrefixCls, direction, switch: SWITCH } = react.useContext(context/* ConfigContext */.E_); // ===================== Disabled ===================== const disabled = react.useContext(DisabledContext/* default */.Z); const mergedDisabled = (customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled) || loading; const prefixCls = getPrefixCls('switch', customizePrefixCls); const loadingIcon = /*#__PURE__*/react.createElement("div", { className: `${prefixCls}-handle` }, loading && /*#__PURE__*/react.createElement(LoadingOutlined/* default */.Z, { className: `${prefixCls}-loading-icon` })); // Style const [wrapSSR, hashId] = switch_style(prefixCls); const mergedSize = (0,useSize/* default */.Z)(customizeSize); const classes = classnames_default()(SWITCH === null || SWITCH === void 0 ? void 0 : SWITCH.className, { [`${prefixCls}-small`]: mergedSize === 'small', [`${prefixCls}-loading`]: loading, [`${prefixCls}-rtl`]: direction === 'rtl' }, className, rootClassName, hashId); const mergedStyle = Object.assign(Object.assign({}, SWITCH === null || SWITCH === void 0 ? void 0 : SWITCH.style), style); return wrapSSR( /*#__PURE__*/react.createElement(wave/* default */.Z, null, /*#__PURE__*/react.createElement(es, Object.assign({}, restProps, { prefixCls: prefixCls, className: classes, style: mergedStyle, disabled: mergedDisabled, ref: ref, loadingIcon: loadingIcon })))); }); switch_Switch.__ANT_SWITCH = true; if (false) {} /* harmony default export */ var es_switch = (switch_Switch); /***/ }), /***/ 58971: /*!*************************************************!*\ !*** ./node_modules/store/dist/store.legacy.js ***! \*************************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { var engine = __webpack_require__(/*! ../src/store-engine */ 62195) var storages = __webpack_require__(/*! ../storages/all */ 39015) var plugins = [__webpack_require__(/*! ../plugins/json2 */ 19257)] module.exports = engine.createStore(storages, plugins) /***/ }), /***/ 19257: /*!*********************************************!*\ !*** ./node_modules/store/plugins/json2.js ***! \*********************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { module.exports = json2Plugin function json2Plugin() { __webpack_require__(/*! ./lib/json2 */ 55703) return {} } /***/ }), /***/ 55703: /*!*************************************************!*\ !*** ./node_modules/store/plugins/lib/json2.js ***! \*************************************************/ /***/ (function() { /* eslint-disable */ // json2.js // 2016-10-28 // Public Domain. // NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. // See http://www.JSON.org/js.html // This code should be minified before deployment. // See http://javascript.crockford.com/jsmin.html // USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO // NOT CONTROL. // This file creates a global JSON object containing two methods: stringify // and parse. This file provides the ES5 JSON capability to ES3 systems. // If a project might run on IE8 or earlier, then this file should be included. // This file does nothing on ES5 systems. // JSON.stringify(value, replacer, space) // value any JavaScript value, usually an object or array. // replacer an optional parameter that determines how object // values are stringified for objects. It can be a // function or an array of strings. // space an optional parameter that specifies the indentation // of nested structures. If it is omitted, the text will // be packed without extra whitespace. If it is a number, // it will specify the number of spaces to indent at each // level. If it is a string (such as "\t" or " "), // it contains the characters used to indent at each level. // This method produces a JSON text from a JavaScript value. // When an object value is found, if the object contains a toJSON // method, its toJSON method will be called and the result will be // stringified. A toJSON method does not serialize: it returns the // value represented by the name/value pair that should be serialized, // or undefined if nothing should be serialized. The toJSON method // will be passed the key associated with the value, and this will be // bound to the value. // For example, this would serialize Dates as ISO strings. // Date.prototype.toJSON = function (key) { // function f(n) { // // Format integers to have at least two digits. // return (n < 10) // ? "0" + n // : n; // } // return this.getUTCFullYear() + "-" + // f(this.getUTCMonth() + 1) + "-" + // f(this.getUTCDate()) + "T" + // f(this.getUTCHours()) + ":" + // f(this.getUTCMinutes()) + ":" + // f(this.getUTCSeconds()) + "Z"; // }; // You can provide an optional replacer method. It will be passed the // key and value of each member, with this bound to the containing // object. The value that is returned from your method will be // serialized. If your method returns undefined, then the member will // be excluded from the serialization. // If the replacer parameter is an array of strings, then it will be // used to select the members to be serialized. It filters the results // such that only members with keys listed in the replacer array are // stringified. // Values that do not have JSON representations, such as undefined or // functions, will not be serialized. Such values in objects will be // dropped; in arrays they will be replaced with null. You can use // a replacer function to replace those with JSON values. // JSON.stringify(undefined) returns undefined. // The optional space parameter produces a stringification of the // value that is filled with line breaks and indentation to make it // easier to read. // If the space parameter is a non-empty string, then that string will // be used for indentation. If the space parameter is a number, then // the indentation will be that many spaces. // Example: // text = JSON.stringify(["e", {pluribus: "unum"}]); // // text is '["e",{"pluribus":"unum"}]' // text = JSON.stringify(["e", {pluribus: "unum"}], null, "\t"); // // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]' // text = JSON.stringify([new Date()], function (key, value) { // return this[key] instanceof Date // ? "Date(" + this[key] + ")" // : value; // }); // // text is '["Date(---current time---)"]' // JSON.parse(text, reviver) // This method parses a JSON text to produce an object or array. // It can throw a SyntaxError exception. // The optional reviver parameter is a function that can filter and // transform the results. It receives each of the keys and values, // and its return value is used instead of the original value. // If it returns what it received, then the structure is not modified. // If it returns undefined then the member is deleted. // Example: // // Parse the text. Values that look like ISO date strings will // // be converted to Date objects. // myData = JSON.parse(text, function (key, value) { // var a; // if (typeof value === "string") { // a = // /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value); // if (a) { // return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], // +a[5], +a[6])); // } // } // return value; // }); // myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) { // var d; // if (typeof value === "string" && // value.slice(0, 5) === "Date(" && // value.slice(-1) === ")") { // d = new Date(value.slice(5, -1)); // if (d) { // return d; // } // } // return value; // }); // This is a reference implementation. You are free to copy, modify, or // redistribute. /*jslint eval, for, this */ /*property JSON, apply, call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours, getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join, lastIndex, length, parse, prototype, push, replace, slice, stringify, test, toJSON, toString, valueOf */ // Create a JSON object only if one does not already exist. We create the // methods in a closure to avoid creating global variables. if (typeof JSON !== "object") { JSON = {}; } (function () { "use strict"; var rx_one = /^[\],:{}\s]*$/; var rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g; var rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; var rx_four = /(?:^|:|,)(?:\s*\[)+/g; var rx_escapable = /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g; var rx_dangerous = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g; function f(n) { // Format integers to have at least two digits. return n < 10 ? "0" + n : n; } function this_value() { return this.valueOf(); } if (typeof Date.prototype.toJSON !== "function") { Date.prototype.toJSON = function () { return isFinite(this.valueOf()) ? this.getUTCFullYear() + "-" + f(this.getUTCMonth() + 1) + "-" + f(this.getUTCDate()) + "T" + f(this.getUTCHours()) + ":" + f(this.getUTCMinutes()) + ":" + f(this.getUTCSeconds()) + "Z" : null; }; Boolean.prototype.toJSON = this_value; Number.prototype.toJSON = this_value; String.prototype.toJSON = this_value; } var gap; var indent; var meta; var rep; function quote(string) { // If the string contains no control characters, no quote characters, and no // backslash characters, then we can safely slap some quotes around it. // Otherwise we must also replace the offending characters with safe escape // sequences. rx_escapable.lastIndex = 0; return rx_escapable.test(string) ? "\"" + string.replace(rx_escapable, function (a) { var c = meta[a]; return typeof c === "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4); }) + "\"" : "\"" + string + "\""; } function str(key, holder) { // Produce a string from holder[key]. var i; // The loop counter. var k; // The member key. var v; // The member value. var length; var mind = gap; var partial; var value = holder[key]; // If the value has a toJSON method, call it to obtain a replacement value. if (value && typeof value === "object" && typeof value.toJSON === "function") { value = value.toJSON(key); } // If we were called with a replacer function, then call the replacer to // obtain a replacement value. if (typeof rep === "function") { value = rep.call(holder, key, value); } // What happens next depends on the value's type. switch (typeof value) { case "string": return quote(value); case "number": // JSON numbers must be finite. Encode non-finite numbers as null. return isFinite(value) ? String(value) : "null"; case "boolean": case "null": // If the value is a boolean or null, convert it to a string. Note: // typeof null does not produce "null". The case is included here in // the remote chance that this gets fixed someday. return String(value); // If the type is "object", we might be dealing with an object or an array or // null. case "object": // Due to a specification blunder in ECMAScript, typeof null is "object", // so watch out for that case. if (!value) { return "null"; } // Make an array to hold the partial results of stringifying this object value. gap += indent; partial = []; // Is the value an array? if (Object.prototype.toString.apply(value) === "[object Array]") { // The value is an array. Stringify every element. Use null as a placeholder // for non-JSON values. length = value.length; for (i = 0; i < length; i += 1) { partial[i] = str(i, value) || "null"; } // Join all of the elements together, separated with commas, and wrap them in // brackets. v = partial.length === 0 ? "[]" : gap ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]" : "[" + partial.join(",") + "]"; gap = mind; return v; } // If the replacer is an array, use it to select the members to be stringified. if (rep && typeof rep === "object") { length = rep.length; for (i = 0; i < length; i += 1) { if (typeof rep[i] === "string") { k = rep[i]; v = str(k, value); if (v) { partial.push(quote(k) + ( gap ? ": " : ":" ) + v); } } } } else { // Otherwise, iterate through all of the keys in the object. for (k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { v = str(k, value); if (v) { partial.push(quote(k) + ( gap ? ": " : ":" ) + v); } } } } // Join all of the member texts together, separated with commas, // and wrap them in braces. v = partial.length === 0 ? "{}" : gap ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}" : "{" + partial.join(",") + "}"; gap = mind; return v; } } // If the JSON object does not yet have a stringify method, give it one. if (typeof JSON.stringify !== "function") { meta = { // table of character substitutions "\b": "\\b", "\t": "\\t", "\n": "\\n", "\f": "\\f", "\r": "\\r", "\"": "\\\"", "\\": "\\\\" }; JSON.stringify = function (value, replacer, space) { // The stringify method takes a value and an optional replacer, and an optional // space parameter, and returns a JSON text. The replacer can be a function // that can replace values, or an array of strings that will select the keys. // A default replacer method can be provided. Use of the space parameter can // produce text that is more easily readable. var i; gap = ""; indent = ""; // If the space parameter is a number, make an indent string containing that // many spaces. if (typeof space === "number") { for (i = 0; i < space; i += 1) { indent += " "; } // If the space parameter is a string, it will be used as the indent string. } else if (typeof space === "string") { indent = space; } // If there is a replacer, it must be a function or an array. // Otherwise, throw an error. rep = replacer; if (replacer && typeof replacer !== "function" && (typeof replacer !== "object" || typeof replacer.length !== "number")) { throw new Error("JSON.stringify"); } // Make a fake root object containing our value under the key of "". // Return the result of stringifying the value. return str("", {"": value}); }; } // If the JSON object does not yet have a parse method, give it one. if (typeof JSON.parse !== "function") { JSON.parse = function (text, reviver) { // The parse method takes a text and an optional reviver function, and returns // a JavaScript value if the text is a valid JSON text. var j; function walk(holder, key) { // The walk method is used to recursively walk the resulting structure so // that modifications can be made. var k; var v; var value = holder[key]; if (value && typeof value === "object") { for (k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { v = walk(value, k); if (v !== undefined) { value[k] = v; } else { delete value[k]; } } } } return reviver.call(holder, key, value); } // Parsing happens in four stages. In the first stage, we replace certain // Unicode characters with escape sequences. JavaScript handles many characters // incorrectly, either silently deleting them, or treating them as line endings. text = String(text); rx_dangerous.lastIndex = 0; if (rx_dangerous.test(text)) { text = text.replace(rx_dangerous, function (a) { return "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4); }); } // In the second stage, we run the text against regular expressions that look // for non-JSON patterns. We are especially concerned with "()" and "new" // because they can cause invocation, and "=" because it can cause mutation. // But just to be safe, we want to reject all unexpected forms. // We split the second stage into 4 regexp operations in order to work around // crippling inefficiencies in IE's and Safari's regexp engines. First we // replace the JSON backslash pairs with "@" (a non-JSON character). Second, we // replace all simple value tokens with "]" characters. Third, we delete all // open brackets that follow a colon or comma or that begin the text. Finally, // we look to see that the remaining characters are only whitespace or "]" or // "," or ":" or "{" or "}". If that is so, then the text is safe for eval. if ( rx_one.test( text .replace(rx_two, "@") .replace(rx_three, "]") .replace(rx_four, "") ) ) { // In the third stage we use the eval function to compile the text into a // JavaScript structure. The "{" operator is subject to a syntactic ambiguity // in JavaScript: it can begin a block or an object literal. We wrap the text // in parens to eliminate the ambiguity. j = eval("(" + text + ")"); // In the optional fourth stage, we recursively walk the new structure, passing // each name/value pair to a reviver function for possible transformation. return (typeof reviver === "function") ? walk({"": j}, "") : j; } // If the text is not JSON parseable, then a SyntaxError is thrown. throw new SyntaxError("JSON.parse"); }; } }()); /***/ }), /***/ 62195: /*!************************************************!*\ !*** ./node_modules/store/src/store-engine.js ***! \************************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { var util = __webpack_require__(/*! ./util */ 69078) var slice = util.slice var pluck = util.pluck var each = util.each var bind = util.bind var create = util.create var isList = util.isList var isFunction = util.isFunction var isObject = util.isObject module.exports = { createStore: createStore } var storeAPI = { version: '2.0.12', enabled: false, // get returns the value of the given key. If that value // is undefined, it returns optionalDefaultValue instead. get: function(key, optionalDefaultValue) { var data = this.storage.read(this._namespacePrefix + key) return this._deserialize(data, optionalDefaultValue) }, // set will store the given value at key and returns value. // Calling set with value === undefined is equivalent to calling remove. set: function(key, value) { if (value === undefined) { return this.remove(key) } this.storage.write(this._namespacePrefix + key, this._serialize(value)) return value }, // remove deletes the key and value stored at the given key. remove: function(key) { this.storage.remove(this._namespacePrefix + key) }, // each will call the given callback once for each key-value pair // in this store. each: function(callback) { var self = this this.storage.each(function(val, namespacedKey) { callback.call(self, self._deserialize(val), (namespacedKey || '').replace(self._namespaceRegexp, '')) }) }, // clearAll will remove all the stored key-value pairs in this store. clearAll: function() { this.storage.clearAll() }, // additional functionality that can't live in plugins // --------------------------------------------------- // hasNamespace returns true if this store instance has the given namespace. hasNamespace: function(namespace) { return (this._namespacePrefix == '__storejs_'+namespace+'_') }, // createStore creates a store.js instance with the first // functioning storage in the list of storage candidates, // and applies the the given mixins to the instance. createStore: function() { return createStore.apply(this, arguments) }, addPlugin: function(plugin) { this._addPlugin(plugin) }, namespace: function(namespace) { return createStore(this.storage, this.plugins, namespace) } } function _warn() { var _console = (typeof console == 'undefined' ? null : console) if (!_console) { return } var fn = (_console.warn ? _console.warn : _console.log) fn.apply(_console, arguments) } function createStore(storages, plugins, namespace) { if (!namespace) { namespace = '' } if (storages && !isList(storages)) { storages = [storages] } if (plugins && !isList(plugins)) { plugins = [plugins] } var namespacePrefix = (namespace ? '__storejs_'+namespace+'_' : '') var namespaceRegexp = (namespace ? new RegExp('^'+namespacePrefix) : null) var legalNamespaces = /^[a-zA-Z0-9_\-]*$/ // alpha-numeric + underscore and dash if (!legalNamespaces.test(namespace)) { throw new Error('store.js namespaces can only have alphanumerics + underscores and dashes') } var _privateStoreProps = { _namespacePrefix: namespacePrefix, _namespaceRegexp: namespaceRegexp, _testStorage: function(storage) { try { var testStr = '__storejs__test__' storage.write(testStr, testStr) var ok = (storage.read(testStr) === testStr) storage.remove(testStr) return ok } catch(e) { return false } }, _assignPluginFnProp: function(pluginFnProp, propName) { var oldFn = this[propName] this[propName] = function pluginFn() { var args = slice(arguments, 0) var self = this // super_fn calls the old function which was overwritten by // this mixin. function super_fn() { if (!oldFn) { return } each(arguments, function(arg, i) { args[i] = arg }) return oldFn.apply(self, args) } // Give mixing function access to super_fn by prefixing all mixin function // arguments with super_fn. var newFnArgs = [super_fn].concat(args) return pluginFnProp.apply(self, newFnArgs) } }, _serialize: function(obj) { return JSON.stringify(obj) }, _deserialize: function(strVal, defaultVal) { if (!strVal) { return defaultVal } // It is possible that a raw string value has been previously stored // in a storage without using store.js, meaning it will be a raw // string value instead of a JSON serialized string. By defaulting // to the raw string value in case of a JSON parse error, we allow // for past stored values to be forwards-compatible with store.js var val = '' try { val = JSON.parse(strVal) } catch(e) { val = strVal } return (val !== undefined ? val : defaultVal) }, _addStorage: function(storage) { if (this.enabled) { return } if (this._testStorage(storage)) { this.storage = storage this.enabled = true } }, _addPlugin: function(plugin) { var self = this // If the plugin is an array, then add all plugins in the array. // This allows for a plugin to depend on other plugins. if (isList(plugin)) { each(plugin, function(plugin) { self._addPlugin(plugin) }) return } // Keep track of all plugins we've seen so far, so that we // don't add any of them twice. var seenPlugin = pluck(this.plugins, function(seenPlugin) { return (plugin === seenPlugin) }) if (seenPlugin) { return } this.plugins.push(plugin) // Check that the plugin is properly formed if (!isFunction(plugin)) { throw new Error('Plugins must be function values that return objects') } var pluginProperties = plugin.call(this) if (!isObject(pluginProperties)) { throw new Error('Plugins must return an object of function properties') } // Add the plugin function properties to this store instance. each(pluginProperties, function(pluginFnProp, propName) { if (!isFunction(pluginFnProp)) { throw new Error('Bad plugin property: '+propName+' from plugin '+plugin.name+'. Plugins should only return functions.') } self._assignPluginFnProp(pluginFnProp, propName) }) }, // Put deprecated properties in the private API, so as to not expose it to accidential // discovery through inspection of the store object. // Deprecated: addStorage addStorage: function(storage) { _warn('store.addStorage(storage) is deprecated. Use createStore([storages])') this._addStorage(storage) } } var store = create(_privateStoreProps, storeAPI, { plugins: [] }) store.raw = {} each(store, function(prop, propName) { if (isFunction(prop)) { store.raw[propName] = bind(store, prop) } }) each(storages, function(storage) { store._addStorage(storage) }) each(plugins, function(plugin) { store._addPlugin(plugin) }) return store } /***/ }), /***/ 69078: /*!****************************************!*\ !*** ./node_modules/store/src/util.js ***! \****************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { var assign = make_assign() var create = make_create() var trim = make_trim() var Global = (typeof window !== 'undefined' ? window : __webpack_require__.g) module.exports = { assign: assign, create: create, trim: trim, bind: bind, slice: slice, each: each, map: map, pluck: pluck, isList: isList, isFunction: isFunction, isObject: isObject, Global: Global } function make_assign() { if (Object.assign) { return Object.assign } else { return function shimAssign(obj, props1, props2, etc) { for (var i = 1; i < arguments.length; i++) { each(Object(arguments[i]), function(val, key) { obj[key] = val }) } return obj } } } function make_create() { if (Object.create) { return function create(obj, assignProps1, assignProps2, etc) { var assignArgsList = slice(arguments, 1) return assign.apply(this, [Object.create(obj)].concat(assignArgsList)) } } else { function F() {} // eslint-disable-line no-inner-declarations return function create(obj, assignProps1, assignProps2, etc) { var assignArgsList = slice(arguments, 1) F.prototype = obj return assign.apply(this, [new F()].concat(assignArgsList)) } } } function make_trim() { if (String.prototype.trim) { return function trim(str) { return String.prototype.trim.call(str) } } else { return function trim(str) { return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '') } } } function bind(obj, fn) { return function() { return fn.apply(obj, Array.prototype.slice.call(arguments, 0)) } } function slice(arr, index) { return Array.prototype.slice.call(arr, index || 0) } function each(obj, fn) { pluck(obj, function(val, key) { fn(val, key) return false }) } function map(obj, fn) { var res = (isList(obj) ? [] : {}) pluck(obj, function(v, k) { res[k] = fn(v, k) return false }) return res } function pluck(obj, fn) { if (isList(obj)) { for (var i=0; i= 0; i--) { if (!trim(cookies[i])) { continue } var kvp = cookies[i].split('=') var key = unescape(kvp[0]) var val = unescape(kvp[1]) callback(val, key) } } function write(key, data) { if(!key) { return } doc.cookie = escape(key) + "=" + escape(data) + "; expires=Tue, 19 Jan 2038 03:14:07 GMT; path=/" } function remove(key) { if (!key || !_has(key)) { return } doc.cookie = escape(key) + "=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/" } function clearAll() { each(function(_, key) { remove(key) }) } function _has(key) { return (new RegExp("(?:^|;\\s*)" + escape(key).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=")).test(doc.cookie) } /***/ }), /***/ 39627: /*!*****************************************************!*\ !*** ./node_modules/store/storages/localStorage.js ***! \*****************************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { var util = __webpack_require__(/*! ../src/util */ 69078) var Global = util.Global module.exports = { name: 'localStorage', read: read, write: write, each: each, remove: remove, clearAll: clearAll, } function localStorage() { return Global.localStorage } function read(key) { return localStorage().getItem(key) } function write(key, data) { return localStorage().setItem(key, data) } function each(fn) { for (var i = localStorage().length - 1; i >= 0; i--) { var key = localStorage().key(i) fn(read(key), key) } } function remove(key) { return localStorage().removeItem(key) } function clearAll() { return localStorage().clear() } /***/ }), /***/ 8728: /*!******************************************************!*\ !*** ./node_modules/store/storages/memoryStorage.js ***! \******************************************************/ /***/ (function(module) { // memoryStorage is a useful last fallback to ensure that the store // is functions (meaning store.get(), store.set(), etc will all function). // However, stored values will not persist when the browser navigates to // a new page or reloads the current page. module.exports = { name: 'memoryStorage', read: read, write: write, each: each, remove: remove, clearAll: clearAll, } var memoryStorage = {} function read(key) { return memoryStorage[key] } function write(key, data) { memoryStorage[key] = data } function each(callback) { for (var key in memoryStorage) { if (memoryStorage.hasOwnProperty(key)) { callback(memoryStorage[key], key) } } } function remove(key) { delete memoryStorage[key] } function clearAll(key) { memoryStorage = {} } /***/ }), /***/ 95347: /*!************************************************************!*\ !*** ./node_modules/store/storages/oldFF-globalStorage.js ***! \************************************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { // oldFF-globalStorage provides storage for Firefox // versions 6 and 7, where no localStorage, etc // is available. var util = __webpack_require__(/*! ../src/util */ 69078) var Global = util.Global module.exports = { name: 'oldFF-globalStorage', read: read, write: write, each: each, remove: remove, clearAll: clearAll, } var globalStorage = Global.globalStorage function read(key) { return globalStorage[key] } function write(key, data) { globalStorage[key] = data } function each(fn) { for (var i = globalStorage.length - 1; i >= 0; i--) { var key = globalStorage.key(i) fn(globalStorage[key], key) } } function remove(key) { return globalStorage.removeItem(key) } function clearAll() { each(function(key, _) { delete globalStorage[key] }) } /***/ }), /***/ 34524: /*!**************************************************************!*\ !*** ./node_modules/store/storages/oldIE-userDataStorage.js ***! \**************************************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { // oldIE-userDataStorage provides storage for Internet Explorer // versions 6 and 7, where no localStorage, sessionStorage, etc // is available. var util = __webpack_require__(/*! ../src/util */ 69078) var Global = util.Global module.exports = { name: 'oldIE-userDataStorage', write: write, read: read, each: each, remove: remove, clearAll: clearAll, } var storageName = 'storejs' var doc = Global.document var _withStorageEl = _makeIEStorageElFunction() var disable = (Global.navigator ? Global.navigator.userAgent : '').match(/ (MSIE 8|MSIE 9|MSIE 10)\./) // MSIE 9.x, MSIE 10.x function write(unfixedKey, data) { if (disable) { return } var fixedKey = fixKey(unfixedKey) _withStorageEl(function(storageEl) { storageEl.setAttribute(fixedKey, data) storageEl.save(storageName) }) } function read(unfixedKey) { if (disable) { return } var fixedKey = fixKey(unfixedKey) var res = null _withStorageEl(function(storageEl) { res = storageEl.getAttribute(fixedKey) }) return res } function each(callback) { _withStorageEl(function(storageEl) { var attributes = storageEl.XMLDocument.documentElement.attributes for (var i=attributes.length-1; i>=0; i--) { var attr = attributes[i] callback(storageEl.getAttribute(attr.name), attr.name) } }) } function remove(unfixedKey) { var fixedKey = fixKey(unfixedKey) _withStorageEl(function(storageEl) { storageEl.removeAttribute(fixedKey) storageEl.save(storageName) }) } function clearAll() { _withStorageEl(function(storageEl) { var attributes = storageEl.XMLDocument.documentElement.attributes storageEl.load(storageName) for (var i=attributes.length-1; i>=0; i--) { storageEl.removeAttribute(attributes[i].name) } storageEl.save(storageName) }) } // Helpers ////////// // In IE7, keys cannot start with a digit or contain certain chars. // See https://github.com/marcuswestin/store.js/issues/40 // See https://github.com/marcuswestin/store.js/issues/83 var forbiddenCharsRegex = new RegExp("[!\"#$%&'()*+,/\\\\:;<=>?@[\\]^`{|}~]", "g") function fixKey(key) { return key.replace(/^\d/, '___$&').replace(forbiddenCharsRegex, '___') } function _makeIEStorageElFunction() { if (!doc || !doc.documentElement || !doc.documentElement.addBehavior) { return null } var scriptTag = 'script', storageOwner, storageContainer, storageEl // Since #userData storage applies only to specific paths, we need to // somehow link our data to a specific path. We choose /favicon.ico // as a pretty safe option, since all browsers already make a request to // this URL anyway and being a 404 will not hurt us here. We wrap an // iframe pointing to the favicon in an ActiveXObject(htmlfile) object // (see: http://msdn.microsoft.com/en-us/library/aa752574(v=VS.85).aspx) // since the iframe access rules appear to allow direct access and // manipulation of the document element, even for a 404 page. This // document can be used instead of the current document (which would // have been limited to the current path) to perform #userData storage. try { /* global ActiveXObject */ storageContainer = new ActiveXObject('htmlfile') storageContainer.open() storageContainer.write('<'+scriptTag+'>document.w=window') storageContainer.close() storageOwner = storageContainer.w.frames[0].document storageEl = storageOwner.createElement('div') } catch(e) { // somehow ActiveXObject instantiation failed (perhaps some special // security settings or otherwse), fall back to per-path storage storageEl = doc.createElement('div') storageOwner = doc.body } return function(storeFunction) { var args = [].slice.call(arguments, 0) args.unshift(storageEl) // See http://msdn.microsoft.com/en-us/library/ms531081(v=VS.85).aspx // and http://msdn.microsoft.com/en-us/library/ms531424(v=VS.85).aspx storageOwner.appendChild(storageEl) storageEl.addBehavior('#default#userData') storageEl.load(storageName) storeFunction.apply(this, args) storageOwner.removeChild(storageEl) return } } /***/ }), /***/ 58855: /*!*******************************************************!*\ !*** ./node_modules/store/storages/sessionStorage.js ***! \*******************************************************/ /***/ (function(module, __unused_webpack_exports, __webpack_require__) { var util = __webpack_require__(/*! ../src/util */ 69078) var Global = util.Global module.exports = { name: 'sessionStorage', read: read, write: write, each: each, remove: remove, clearAll: clearAll } function sessionStorage() { return Global.sessionStorage } function read(key) { return sessionStorage().getItem(key) } function write(key, data) { return sessionStorage().setItem(key, data) } function each(fn) { for (var i = sessionStorage().length - 1; i >= 0; i--) { var key = sessionStorage().key(i) fn(read(key), key) } } function remove(key) { return sessionStorage().removeItem(key) } function clearAll() { return sessionStorage().clear() } /***/ }) }]);