(() => {
    var __webpack_modules__ = [ (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        var _customizer_polyfill__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
        var _customizer_polyfill__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_customizer_polyfill__WEBPACK_IMPORTED_MODULE_0__);
        var _customizer_events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
        var _customizer_preview_events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
        var _customizer_index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
        var _customizer_controls__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(73);
        Object.keys(_customizer_controls__WEBPACK_IMPORTED_MODULE_4__["default"]).forEach((function(id) {
            (0, _customizer_index__WEBPACK_IMPORTED_MODULE_3__.defineCustomizerControl)(id, _customizer_controls__WEBPACK_IMPORTED_MODULE_4__["default"][id]);
        }));
    }, () => {
        if (Array.prototype.findIndex === undefined) {
            Array.prototype.findIndex = function(cb) {
                for (var i = 0; i < this.length; i++) {
                    if (cb(this[i]) === true) {
                        return i;
                    }
                }
                return -1;
            };
        }
        if (String.prototype.startsWith === undefined) {
            String.prototype.startsWith = function(needle, pos) {
                pos = pos || 0;
                return this.indexOf(needle, pos) === pos;
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Events = function() {
            function Events() {
                _classCallCheck(this, Events);
                _defineProperty(this, "hooks", {});
            }
            _createClass(Events, [ {
                key: "trigger",
                value: function trigger(name) {
                    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                        args[_key - 1] = arguments[_key];
                    }
                    (this.hooks[name] || []).forEach((function(cb) {
                        cb.apply(void 0, args);
                    }));
                }
            }, {
                key: "bind",
                value: function bind(name, callback) {
                    var _this = this;
                    if (!this.hooks[name]) {
                        this.hooks[name] = [];
                    }
                    this.hooks[name].push(callback);
                    return function() {
                        _this.hooks[name].splice(_this.hooks[name].indexOf(callback), 1);
                    };
                }
            } ]);
            return Events;
        }();
        if (!window.LottaEvents) {
            window.LottaEvents = new Events;
        }
        const __WEBPACK_DEFAULT_EXPORT__ = window.LottaEvents;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
        if (!window.Lotta) {
            window.Lotta = {};
        }
        window.Lotta.expand = function(location) {
            setTimeout((function() {
                var path = location.split(":");
                var section = path.shift();
                var expanded = Object.values(wp.customize.section._value).find((function(e) {
                    return e.expanded();
                }));
                LottaEvents.trigger("lotta-before-expand-panel", path);
                var timeout = 0;
                if (!expanded || expanded.id !== section) {
                    var s = wp.customize.section(section);
                    s && s.expand();
                    timeout = 180;
                }
                if (path.length > 0) {
                    setTimeout((function() {
                        return LottaEvents.trigger("lotta-expand-panel", path);
                    }), timeout);
                }
            }));
        };
        if (wp.customize) {
            wp.customize.bind("ready", (function() {
                wp.customize.previewer.bind("lotta-initiate-deep-link", (function(location) {
                    Lotta.expand(location);
                }));
                var params = (0, _utils__WEBPACK_IMPORTED_MODULE_0__.getQueryParams)(window.location.search);
                if (params.lotta_auto_focus) {
                    window.Lotta.expand(params.lotta_auto_focus);
                }
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            array_flat: () => array_flat,
            array_unique: () => array_unique,
            capitalize: () => capitalize,
            clamp: () => clamp,
            clampMax: () => clampMax,
            composeEventHandlers: () => composeEventHandlers,
            generateFontFacesCss: () => generateFontFacesCss,
            getColorValue: () => getColorValue,
            getQueryParams: () => getQueryParams,
            in_array: () => in_array,
            loadCustomFonts: () => loadCustomFonts,
            round: () => round,
            roundWholeNumbers: () => roundWholeNumbers,
            sanitize_array_value: () => sanitize_array_value
        });
        var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
        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);
        }
        function _createForOfIteratorHelper(o, allowArrayLike) {
            var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
            if (!it) {
                if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
                    if (it) o = it;
                    var i = 0;
                    var F = function F() {};
                    return {
                        s: F,
                        n: function n() {
                            if (i >= o.length) return {
                                done: true
                            };
                            return {
                                done: false,
                                value: o[i++]
                            };
                        },
                        e: function e(_e) {
                            throw _e;
                        },
                        f: F
                    };
                }
                throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
            }
            var normalCompletion = true, didErr = false, err;
            return {
                s: function s() {
                    it = it.call(o);
                },
                n: function n() {
                    var step = it.next();
                    normalCompletion = step.done;
                    return step;
                },
                e: function e(_e2) {
                    didErr = true;
                    err = _e2;
                },
                f: function f() {
                    try {
                        if (!normalCompletion && it["return"] != null) it["return"]();
                    } finally {
                        if (didErr) throw err;
                    }
                }
            };
        }
        function _toArray(arr) {
            return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        var getQueryParams = function getQueryParams(url) {
            if (!url) {
                return {};
            }
            var query = url.split("?")[1];
            if (!query) {
                return {};
            }
            var params = {};
            var paramsArr = query.split("&");
            for (var i = 0, len = paramsArr.length; i < len; i++) {
                var param = paramsArr[i].split("=");
                params[param[0]] = param[1];
            }
            return params;
        };
        var clamp = function clamp(min, max, value) {
            return Math.max(min, Math.min(max, value));
        };
        var clampMax = function clampMax(max, value) {
            return Math.min(max, value);
        };
        var round = function round(value) {
            var decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
            var multiplier = Math.pow(10, decimalPlaces);
            return Math.round(value * multiplier + Number.EPSILON) / multiplier;
        };
        var roundWholeNumbers = function roundWholeNumbers(num, precision) {
            num = parseFloat(num);
            if (!precision) return num;
            return Math.round(num / precision) * precision;
        };
        var composeEventHandlers = function composeEventHandlers() {
            for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
                fns[_key] = arguments[_key];
            }
            return function(event) {
                for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                    args[_key2 - 1] = arguments[_key2];
                }
                return fns.every((function(fn) {
                    return fn && fn.apply(void 0, [ event ].concat(args));
                }));
            };
        };
        var getColorValue = function getColorValue(color) {
            if (!color || color === _index__WEBPACK_IMPORTED_MODULE_0__.CSS_INITIAL_VALUE) {
                return "#ffffff";
            }
            if (color.indexOf("var") > -1) {
                var value = getComputedStyle(document.documentElement).getPropertyValue(color.replace(/var\(/, "").replace(/\)/, "")).trim().replace(/\s/g, "");
                if (value.indexOf("#") === -1 && value.indexOf("rgb") === -1) {
                    return "rgb(".concat(value, ")");
                }
                return value;
            }
            return color;
        };
        var capitalize = function capitalize(_ref) {
            var _ref2 = _toArray(_ref), first = _ref2[0], rest = _ref2.slice(1);
            var lowerRest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
            return first.toUpperCase() + (lowerRest ? rest.join("").toLowerCase() : rest.join(""));
        };
        function in_array(needle, haystack) {
            return haystack.indexOf(needle) !== -1;
        }
        function array_unique(arr) {
            return Array.from(new Set(arr));
        }
        function array_flat(arr) {
            var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
            var _iterator = _createForOfIteratorHelper(arr), _step;
            try {
                for (_iterator.s(); !(_step = _iterator.n()).done; ) {
                    var key = _step.value;
                    if (Array.isArray(key)) {
                        array_flat(key, target);
                    } else if (_typeof(key) === "object") {
                        if (key !== null && key !== undefined) {
                            array_flat(Object.values(key), target);
                        }
                    } else {
                        target.push(key);
                    }
                }
            } catch (err) {
                _iterator.e(err);
            } finally {
                _iterator.f();
            }
            return target;
        }
        function sanitize_array_value(v) {
            return Array.isArray(v) ? v : [];
        }
        function generateFontFacesCss(fonts) {
            var parse_css = "";
            fonts.forEach((function(font) {
                parse_css += "@font-face {";
                parse_css += "font-family: '".concat(font["f"], "';");
                parse_css += "font-weight: '".concat(font["v"], "';");
                font["u"].forEach((function(src) {
                    if (src.indexOf(".otf") !== -1) {
                        parse_css += "src: url('".concat(src, '\') format("opentype");');
                    } else if (src.indexOf(".ttf") !== -1) {
                        parse_css += "src: url('".concat(src, '\') format("truetype");');
                    } else if (src.indexOf(".woff2") !== -1) {
                        parse_css += "src: url('".concat(src, '\') format("woff2");');
                    } else if (src.indexOf(".woff") !== -1) {
                        parse_css += "src: url('".concat(src, '\') format("woff");');
                    }
                }));
                parse_css += "}";
            }));
            return parse_css;
        }
        var loadCustomFonts = function loadCustomFonts(fonts) {
            if (fonts.length <= 0 || !window.Lotta || !window.Lotta.customizer.settings) {
                return;
            }
            var custom_fonts = window.Lotta.customizer.settings.custom_fonts;
            var parse_css = generateFontFacesCss(fonts.map((function(f) {
                return custom_fonts[f];
            })));
            jQuery("style#lotta-dynamic-custom-fonts-loader").remove();
            jQuery("head").append('<style id="lotta-dynamic-custom-fonts-loader">' + parse_css + "</style>");
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            CONTAINER_CONTROL: () => CONTAINER_CONTROL,
            CSS_INITIAL_VALUE: () => CSS_INITIAL_VALUE,
            CZ_VALUES: () => CZ_VALUES,
            buildControl: () => buildControl,
            buildNestedControls: () => buildNestedControls,
            defineCustomizerControl: () => defineCustomizerControl
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _control_wrapper__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
        var _nested_controls__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(71);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        var _excluded = [ "wrapperAttr" ];
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        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;
        }
        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;
        }
        var CZ_VALUES = "__CZ_VALUES__";
        var CONTAINER_CONTROL = "__LOTTA_CONTAINER_CONTROL__";
        var CSS_INITIAL_VALUE = "__INITIAL_VALUE__";
        var buildNestedControls = function buildNestedControls(_ref) {
            var controls = _ref.controls, _onChange = _ref.onChange, settings = _ref.settings;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_nested_controls__WEBPACK_IMPORTED_MODULE_2__["default"], {
                onChange: function onChange(val, id, self) {
                    _onChange(val, id, self);
                },
                controls,
                value: settings ? settings : CZ_VALUES
            });
        };
        var buildControl = function buildControl(_ref2) {
            var options = _ref2.options, value = _ref2.value, settings = _ref2.settings, id = _ref2.id, onChange = _ref2.onChange, Component = _ref2.Component;
            var design = "block";
            var ControlMetaWrapper = null;
            var wrapperAttr = {};
            if (Component.MetaWrapper) {
                ControlMetaWrapper = Component.MetaWrapper;
            }
            if (Component.wrapperAttr) {
                wrapperAttr = Component.wrapperAttr;
            }
            if (Component.renderingConfig) {
                design = Component.renderingConfig.design || design;
            }
            if (options.design) {
                design = options.design;
            }
            var _getActualControl = function getActualControl() {
                var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
                var _ref3$wrapperAttr = _ref3.wrapperAttr, additionalWrapperAttr = _ref3$wrapperAttr === void 0 ? {} : _ref3$wrapperAttr, props = _objectWithoutProperties(_ref3, _excluded);
                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_control_wrapper__WEBPACK_IMPORTED_MODULE_1__["default"], {
                    design,
                    id,
                    wrapperAttr: _objectSpread(_objectSpread(_objectSpread({}, wrapperAttr), options.wrapperAttr), additionalWrapperAttr),
                    settings,
                    options,
                    value,
                    onChange,
                    Control: Component
                });
            };
            return ControlMetaWrapper ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(ControlMetaWrapper, {
                id,
                options,
                settings,
                onChange,
                value,
                getActualControl: function getActualControl(props) {
                    return _getActualControl(props);
                }
            }) : _getActualControl();
        };
        var defineCustomizerControl = function defineCustomizerControl(type, Component) {
            wp.customize.controlConstructor[type] = wp.customize.Control.extend({
                initialize: function initialize(id, params) {
                    var control = this;
                    wp.customize.Control.prototype.initialize.call(control, id, params);
                    function onRemoved(removedControl) {
                        if (control === removedControl) {
                            control.destroy();
                            control.container.remove();
                            wp.customize.control.unbind("removed", onRemoved);
                        }
                    }
                    wp.customize.control.bind("removed", onRemoved);
                },
                renderContent: function renderContent() {
                    var _this = this;
                    var options = Object.assign({}, this.params, this.params.options || {});
                    var controlEl = buildControl({
                        id: this.id,
                        options,
                        value: this.setting.get(),
                        onChange: function onChange(v, id) {
                            id = id || _this.id;
                            if (wp.customize(id)) {
                                wp.customize(id).set(v);
                            }
                            LottaEvents.trigger("lotta-setting-change", id, v);
                        },
                        Component
                    });
                    if (_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot) {
                        if (!this.reactDOMRoot) {
                            this.reactDOMRoot = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot)(this.container[0]);
                        }
                        this.reactDOMRoot.render(controlEl);
                    } else {
                        (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.render)(controlEl, this.container[0]);
                    }
                },
                ready: function ready() {
                    var _this2 = this;
                    this.setting.bind((function() {
                        return _this2.renderContent();
                    }));
                },
                destroy: function destroy() {
                    if (this.reactDOMRoot) {
                        this.reactDOMRoot.unmount();
                        this.reactDOMRoot = null;
                    } else {
                        (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.unmountComponentAtNode)(this.container[0]);
                    }
                    if (wp.customize.Control.prototype.destroy) {
                        wp.customize.Control.prototype.destroy.call(this);
                    }
                }
            });
        };
    }, module => {
        "use strict";
        module.exports = window.wp.element;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => ControlWrapper,
            promoteScalarValueIntoResponsive: () => promoteScalarValueIntoResponsive
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _responsive_controls__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var deep_equal__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_3__);
        var _index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5);
        var underscore__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(70);
        var underscore__WEBPACK_IMPORTED_MODULE_5___default = __webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_5__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(10);
        var _excluded = [ "className" ];
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        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;
        }
        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;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        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);
        }
        var promoteScalarValueIntoResponsive = function promoteScalarValueIntoResponsive(value) {
            var fill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
            var valueWithResponsive = _typeof(value) === "object" && Object.keys(value).indexOf("desktop") > -1 ? underscore__WEBPACK_IMPORTED_MODULE_5___default().clone(value) : {
                desktop: underscore__WEBPACK_IMPORTED_MODULE_5___default().clone(value),
                tablet: _index__WEBPACK_IMPORTED_MODULE_4__.CSS_INITIAL_VALUE,
                mobile: _index__WEBPACK_IMPORTED_MODULE_4__.CSS_INITIAL_VALUE
            };
            if (fill) {
                if (valueWithResponsive["tablet"] === _index__WEBPACK_IMPORTED_MODULE_4__.CSS_INITIAL_VALUE) {
                    valueWithResponsive["tablet"] = underscore__WEBPACK_IMPORTED_MODULE_5___default().clone(valueWithResponsive["desktop"]);
                }
                if (valueWithResponsive["mobile"] === _index__WEBPACK_IMPORTED_MODULE_4__.CSS_INITIAL_VALUE) {
                    valueWithResponsive["mobile"] = underscore__WEBPACK_IMPORTED_MODULE_5___default().clone(valueWithResponsive["tablet"]);
                }
            }
            return valueWithResponsive;
        };
        var ControlWrapper = function(_Component) {
            _inherits(ControlWrapper, _Component);
            var _super = _createSuper(ControlWrapper);
            function ControlWrapper() {
                var _this;
                _classCallCheck(this, ControlWrapper);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    device: wp.customize && wp.customize.previewedDevice ? wp.customize.previewedDevice() : "desktop"
                });
                _defineProperty(_assertThisInitialized(_this), "listener", (function() {
                    return _this.setState({
                        device: wp.customize && wp.customize.previewedDevice ? wp.customize.previewedDevice() : "desktop"
                    });
                }));
                return _this;
            }
            _createClass(ControlWrapper, [ {
                key: "componentDidMount",
                value: function componentDidMount() {
                    var _this2 = this;
                    if (!this.props.options.responsive) return;
                    if (!wp.customize) return;
                    setTimeout((function() {
                        return wp.customize.previewedDevice.bind(_this2.listener);
                    }), 1e3);
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    if (!this.props.options.responsive) return;
                    if (!wp.customize) return;
                    wp.customize.previewedDevice.unbind(this.listener);
                }
            }, {
                key: "setDevice",
                value: function setDevice(device) {
                    this.setState({
                        device
                    });
                    wp.customize && wp.customize.previewedDevice.set(device);
                }
            }, {
                key: "render",
                value: function render() {
                    var _this3 = this;
                    var _this$props = this.props, id = _this$props.id, options = _this$props.options, design = _this$props.design, value = _this$props.value, settings = _this$props.settings, Control = _this$props.Control, onChange = _this$props.onChange, _this$props$wrapperAt = _this$props.wrapperAttr, className = _this$props$wrapperAt.className, wrapperAttr = _objectWithoutProperties(_this$props$wrapperAt, _excluded);
                    if (design === "none") {
                        return null;
                    }
                    var valueWithResponsive = options.responsive ? promoteScalarValueIntoResponsive(value, true)[this.state.device] : value;
                    var onChangeWithMobileBridge = function onChangeWithMobileBridge(v) {
                        if (options.switchDeviceOnChange && wp.customize && wp.customize.previewedDevice() !== option.switchDeviceOnChange) {
                            wp.customize.previewedDevice.set(option.switchDeviceOnChange);
                        }
                        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                            args[_key2 - 1] = arguments[_key2];
                        }
                        onChange.apply(void 0, [ v ].concat(args));
                    };
                    var onChangeWithResponsiveBridge = function onChangeWithResponsiveBridge(scalarValue) {
                        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
                            args[_key3 - 1] = arguments[_key3];
                        }
                        onChangeWithMobileBridge.apply(void 0, [ options.responsive ? _objectSpread(_objectSpread({}, promoteScalarValueIntoResponsive(value)), {}, _defineProperty({}, _this3.state.device, scalarValue)) : scalarValue ].concat(args));
                    };
                    if (design === "raw") {
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(Control, {
                            id,
                            onChange: onChangeWithResponsiveBridge,
                            value: valueWithResponsive,
                            options,
                            settings
                        });
                    }
                    var label = Object.keys(options).indexOf("label") === -1 ? (id || "").replace(/./, (function(s) {
                        return s.toUpperCase();
                    })).replace(/\_|\-/g, " ") : options.label;
                    var desc = Object.keys(options).indexOf("description") === -1 ? false : options.description;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", _objectSpread(_objectSpread({
                        "data-design": design,
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])("lotta-control", "".concat(options.type, "-control"), className, {
                            "no-label": !!options.hideLabel
                        })
                    }, wrapperAttr), {}, {
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("header", {
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("label", {
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("span", {
                                    children: label
                                }), !(options.disableRevert || Control.disableRevert) && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("button", {
                                    type: "button",
                                    disabled: options["default"] === undefined || deep_equal__WEBPACK_IMPORTED_MODULE_3___default()(options["default"], value),
                                    className: "lotta-revert",
                                    onClick: function onClick() {
                                        onChange(options["default"]);
                                    }
                                }) ]
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                children: options.responsive && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_responsive_controls__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                    device: this.state.device,
                                    responsiveDescriptor: options.responsive,
                                    setDevice: function setDevice(device) {
                                        return _this3.setDevice(device);
                                    }
                                })
                            }) ]
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("section", {
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(Control, {
                                id,
                                onChange: onChangeWithResponsiveBridge,
                                value: valueWithResponsive,
                                options,
                                settings
                            })
                        }), desc && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                            className: "lotta-control-desc",
                            dangerouslySetInnerHTML: {
                                __html: desc
                            }
                        }) ]
                    }));
                }
            } ]);
            return ControlWrapper;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => ResponsiveControls
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var ResponsiveControls = function(_Component) {
            _inherits(ResponsiveControls, _Component);
            var _super = _createSuper(ResponsiveControls);
            function ResponsiveControls() {
                _classCallCheck(this, ResponsiveControls);
                return _super.apply(this, arguments);
            }
            _createClass(ResponsiveControls, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, device = _this$props.device, setDevice = _this$props.setDevice, responsiveDescriptor = _this$props.responsiveDescriptor;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                        className: "lotta-control-devices",
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("ul", {
                            className: "lotta-responsive-controls lotta-devices",
                            children: [ "desktop", "tablet", "mobile" ].map((function(d) {
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("li", {
                                    onClick: function onClick() {
                                        return setDevice(d);
                                    },
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])({
                                        active: d === device,
                                        responsiveDescriptor
                                    }, "lotta-".concat(d))
                                }, d);
                            }))
                        })
                    });
                }
            } ]);
            return ResponsiveControls;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        function toVal(mix) {
            var k, y, str = "";
            if (typeof mix === "string" || typeof mix === "number") {
                str += mix;
            } else if (typeof mix === "object") {
                if (Array.isArray(mix)) {
                    for (k = 0; k < mix.length; k++) {
                        if (mix[k]) {
                            if (y = toVal(mix[k])) {
                                str && (str += " ");
                                str += y;
                            }
                        }
                    }
                } else {
                    for (k in mix) {
                        if (mix[k]) {
                            str && (str += " ");
                            str += k;
                        }
                    }
                }
            }
            return str;
        }
        function __WEBPACK_DEFAULT_EXPORT__() {
            var i = 0, tmp, x, str = "";
            while (i < arguments.length) {
                if (tmp = arguments[i++]) {
                    if (x = toVal(tmp)) {
                        str && (str += " ");
                        str += x;
                    }
                }
            }
            return str;
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        if (false) {} else {
            module.exports = __webpack_require__(11);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        /** @license React v17.0.2
 * react-jsx-runtime.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */        if (true) {
            (function() {
                "use strict";
                var React = __webpack_require__(12);
                var _assign = __webpack_require__(13);
                var REACT_ELEMENT_TYPE = 60103;
                var REACT_PORTAL_TYPE = 60106;
                exports.Fragment = 60107;
                var REACT_STRICT_MODE_TYPE = 60108;
                var REACT_PROFILER_TYPE = 60114;
                var REACT_PROVIDER_TYPE = 60109;
                var REACT_CONTEXT_TYPE = 60110;
                var REACT_FORWARD_REF_TYPE = 60112;
                var REACT_SUSPENSE_TYPE = 60113;
                var REACT_SUSPENSE_LIST_TYPE = 60120;
                var REACT_MEMO_TYPE = 60115;
                var REACT_LAZY_TYPE = 60116;
                var REACT_BLOCK_TYPE = 60121;
                var REACT_SERVER_BLOCK_TYPE = 60122;
                var REACT_FUNDAMENTAL_TYPE = 60117;
                var REACT_SCOPE_TYPE = 60119;
                var REACT_OPAQUE_ID_TYPE = 60128;
                var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
                var REACT_OFFSCREEN_TYPE = 60130;
                var REACT_LEGACY_HIDDEN_TYPE = 60131;
                if (typeof Symbol === "function" && Symbol.for) {
                    var symbolFor = Symbol.for;
                    REACT_ELEMENT_TYPE = symbolFor("react.element");
                    REACT_PORTAL_TYPE = symbolFor("react.portal");
                    exports.Fragment = symbolFor("react.fragment");
                    REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
                    REACT_PROFILER_TYPE = symbolFor("react.profiler");
                    REACT_PROVIDER_TYPE = symbolFor("react.provider");
                    REACT_CONTEXT_TYPE = symbolFor("react.context");
                    REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
                    REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
                    REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
                    REACT_MEMO_TYPE = symbolFor("react.memo");
                    REACT_LAZY_TYPE = symbolFor("react.lazy");
                    REACT_BLOCK_TYPE = symbolFor("react.block");
                    REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
                    REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
                    REACT_SCOPE_TYPE = symbolFor("react.scope");
                    REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
                    REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
                    REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
                    REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
                }
                var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
                var FAUX_ITERATOR_SYMBOL = "@@iterator";
                function getIteratorFn(maybeIterable) {
                    if (maybeIterable === null || typeof maybeIterable !== "object") {
                        return null;
                    }
                    var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
                    if (typeof maybeIterator === "function") {
                        return maybeIterator;
                    }
                    return null;
                }
                var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
                function error(format) {
                    {
                        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                            args[_key2 - 1] = arguments[_key2];
                        }
                        printWarning("error", format, args);
                    }
                }
                function printWarning(level, format, args) {
                    {
                        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
                        var stack = ReactDebugCurrentFrame.getStackAddendum();
                        if (stack !== "") {
                            format += "%s";
                            args = args.concat([ stack ]);
                        }
                        var argsWithFormat = args.map((function(item) {
                            return "" + item;
                        }));
                        argsWithFormat.unshift("Warning: " + format);
                        Function.prototype.apply.call(console[level], console, argsWithFormat);
                    }
                }
                var enableScopeAPI = false;
                function isValidElementType(type) {
                    if (typeof type === "string" || typeof type === "function") {
                        return true;
                    }
                    if (type === exports.Fragment || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) {
                        return true;
                    }
                    if (typeof type === "object" && type !== null) {
                        if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
                            return true;
                        }
                    }
                    return false;
                }
                function getWrappedName(outerType, innerType, wrapperName) {
                    var functionName = innerType.displayName || innerType.name || "";
                    return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
                }
                function getContextName(type) {
                    return type.displayName || "Context";
                }
                function getComponentName(type) {
                    if (type == null) {
                        return null;
                    }
                    {
                        if (typeof type.tag === "number") {
                            error("Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
                        }
                    }
                    if (typeof type === "function") {
                        return type.displayName || type.name || null;
                    }
                    if (typeof type === "string") {
                        return type;
                    }
                    switch (type) {
                      case exports.Fragment:
                        return "Fragment";

                      case REACT_PORTAL_TYPE:
                        return "Portal";

                      case REACT_PROFILER_TYPE:
                        return "Profiler";

                      case REACT_STRICT_MODE_TYPE:
                        return "StrictMode";

                      case REACT_SUSPENSE_TYPE:
                        return "Suspense";

                      case REACT_SUSPENSE_LIST_TYPE:
                        return "SuspenseList";
                    }
                    if (typeof type === "object") {
                        switch (type.$$typeof) {
                          case REACT_CONTEXT_TYPE:
                            var context = type;
                            return getContextName(context) + ".Consumer";

                          case REACT_PROVIDER_TYPE:
                            var provider = type;
                            return getContextName(provider._context) + ".Provider";

                          case REACT_FORWARD_REF_TYPE:
                            return getWrappedName(type, type.render, "ForwardRef");

                          case REACT_MEMO_TYPE:
                            return getComponentName(type.type);

                          case REACT_BLOCK_TYPE:
                            return getComponentName(type._render);

                          case REACT_LAZY_TYPE:
                            {
                                var lazyComponent = type;
                                var payload = lazyComponent._payload;
                                var init = lazyComponent._init;
                                try {
                                    return getComponentName(init(payload));
                                } catch (x) {
                                    return null;
                                }
                            }
                        }
                    }
                    return null;
                }
                var disabledDepth = 0;
                var prevLog;
                var prevInfo;
                var prevWarn;
                var prevError;
                var prevGroup;
                var prevGroupCollapsed;
                var prevGroupEnd;
                function disabledLog() {}
                disabledLog.__reactDisabledLog = true;
                function disableLogs() {
                    {
                        if (disabledDepth === 0) {
                            prevLog = console.log;
                            prevInfo = console.info;
                            prevWarn = console.warn;
                            prevError = console.error;
                            prevGroup = console.group;
                            prevGroupCollapsed = console.groupCollapsed;
                            prevGroupEnd = console.groupEnd;
                            var props = {
                                configurable: true,
                                enumerable: true,
                                value: disabledLog,
                                writable: true
                            };
                            Object.defineProperties(console, {
                                info: props,
                                log: props,
                                warn: props,
                                error: props,
                                group: props,
                                groupCollapsed: props,
                                groupEnd: props
                            });
                        }
                        disabledDepth++;
                    }
                }
                function reenableLogs() {
                    {
                        disabledDepth--;
                        if (disabledDepth === 0) {
                            var props = {
                                configurable: true,
                                enumerable: true,
                                writable: true
                            };
                            Object.defineProperties(console, {
                                log: _assign({}, props, {
                                    value: prevLog
                                }),
                                info: _assign({}, props, {
                                    value: prevInfo
                                }),
                                warn: _assign({}, props, {
                                    value: prevWarn
                                }),
                                error: _assign({}, props, {
                                    value: prevError
                                }),
                                group: _assign({}, props, {
                                    value: prevGroup
                                }),
                                groupCollapsed: _assign({}, props, {
                                    value: prevGroupCollapsed
                                }),
                                groupEnd: _assign({}, props, {
                                    value: prevGroupEnd
                                })
                            });
                        }
                        if (disabledDepth < 0) {
                            error("disabledDepth fell below zero. " + "This is a bug in React. Please file an issue.");
                        }
                    }
                }
                var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
                var prefix;
                function describeBuiltInComponentFrame(name, source, ownerFn) {
                    {
                        if (prefix === undefined) {
                            try {
                                throw Error();
                            } catch (x) {
                                var match = x.stack.trim().match(/\n( *(at )?)/);
                                prefix = match && match[1] || "";
                            }
                        }
                        return "\n" + prefix + name;
                    }
                }
                var reentry = false;
                var componentFrameCache;
                {
                    var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
                    componentFrameCache = new PossiblyWeakMap;
                }
                function describeNativeComponentFrame(fn, construct) {
                    if (!fn || reentry) {
                        return "";
                    }
                    {
                        var frame = componentFrameCache.get(fn);
                        if (frame !== undefined) {
                            return frame;
                        }
                    }
                    var control;
                    reentry = true;
                    var previousPrepareStackTrace = Error.prepareStackTrace;
                    Error.prepareStackTrace = undefined;
                    var previousDispatcher;
                    {
                        previousDispatcher = ReactCurrentDispatcher.current;
                        ReactCurrentDispatcher.current = null;
                        disableLogs();
                    }
                    try {
                        if (construct) {
                            var Fake = function() {
                                throw Error();
                            };
                            Object.defineProperty(Fake.prototype, "props", {
                                set: function() {
                                    throw Error();
                                }
                            });
                            if (typeof Reflect === "object" && Reflect.construct) {
                                try {
                                    Reflect.construct(Fake, []);
                                } catch (x) {
                                    control = x;
                                }
                                Reflect.construct(fn, [], Fake);
                            } else {
                                try {
                                    Fake.call();
                                } catch (x) {
                                    control = x;
                                }
                                fn.call(Fake.prototype);
                            }
                        } else {
                            try {
                                throw Error();
                            } catch (x) {
                                control = x;
                            }
                            fn();
                        }
                    } catch (sample) {
                        if (sample && control && typeof sample.stack === "string") {
                            var sampleLines = sample.stack.split("\n");
                            var controlLines = control.stack.split("\n");
                            var s = sampleLines.length - 1;
                            var c = controlLines.length - 1;
                            while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
                                c--;
                            }
                            for (;s >= 1 && c >= 0; s--, c--) {
                                if (sampleLines[s] !== controlLines[c]) {
                                    if (s !== 1 || c !== 1) {
                                        do {
                                            s--;
                                            c--;
                                            if (c < 0 || sampleLines[s] !== controlLines[c]) {
                                                var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
                                                {
                                                    if (typeof fn === "function") {
                                                        componentFrameCache.set(fn, _frame);
                                                    }
                                                }
                                                return _frame;
                                            }
                                        } while (s >= 1 && c >= 0);
                                    }
                                    break;
                                }
                            }
                        }
                    } finally {
                        reentry = false;
                        {
                            ReactCurrentDispatcher.current = previousDispatcher;
                            reenableLogs();
                        }
                        Error.prepareStackTrace = previousPrepareStackTrace;
                    }
                    var name = fn ? fn.displayName || fn.name : "";
                    var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
                    {
                        if (typeof fn === "function") {
                            componentFrameCache.set(fn, syntheticFrame);
                        }
                    }
                    return syntheticFrame;
                }
                function describeFunctionComponentFrame(fn, source, ownerFn) {
                    {
                        return describeNativeComponentFrame(fn, false);
                    }
                }
                function shouldConstruct(Component) {
                    var prototype = Component.prototype;
                    return !!(prototype && prototype.isReactComponent);
                }
                function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
                    if (type == null) {
                        return "";
                    }
                    if (typeof type === "function") {
                        {
                            return describeNativeComponentFrame(type, shouldConstruct(type));
                        }
                    }
                    if (typeof type === "string") {
                        return describeBuiltInComponentFrame(type);
                    }
                    switch (type) {
                      case REACT_SUSPENSE_TYPE:
                        return describeBuiltInComponentFrame("Suspense");

                      case REACT_SUSPENSE_LIST_TYPE:
                        return describeBuiltInComponentFrame("SuspenseList");
                    }
                    if (typeof type === "object") {
                        switch (type.$$typeof) {
                          case REACT_FORWARD_REF_TYPE:
                            return describeFunctionComponentFrame(type.render);

                          case REACT_MEMO_TYPE:
                            return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);

                          case REACT_BLOCK_TYPE:
                            return describeFunctionComponentFrame(type._render);

                          case REACT_LAZY_TYPE:
                            {
                                var lazyComponent = type;
                                var payload = lazyComponent._payload;
                                var init = lazyComponent._init;
                                try {
                                    return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
                                } catch (x) {}
                            }
                        }
                    }
                    return "";
                }
                var loggedTypeFailures = {};
                var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
                function setCurrentlyValidatingElement(element) {
                    {
                        if (element) {
                            var owner = element._owner;
                            var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
                            ReactDebugCurrentFrame.setExtraStackFrame(stack);
                        } else {
                            ReactDebugCurrentFrame.setExtraStackFrame(null);
                        }
                    }
                }
                function checkPropTypes(typeSpecs, values, location, componentName, element) {
                    {
                        var has = Function.call.bind(Object.prototype.hasOwnProperty);
                        for (var typeSpecName in typeSpecs) {
                            if (has(typeSpecs, typeSpecName)) {
                                var error$1 = void 0;
                                try {
                                    if (typeof typeSpecs[typeSpecName] !== "function") {
                                        var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
                                        err.name = "Invariant Violation";
                                        throw err;
                                    }
                                    error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
                                } catch (ex) {
                                    error$1 = ex;
                                }
                                if (error$1 && !(error$1 instanceof Error)) {
                                    setCurrentlyValidatingElement(element);
                                    error("%s: type specification of %s" + " `%s` is invalid; the type checker " + "function must return `null` or an `Error` but returned a %s. " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
                                    setCurrentlyValidatingElement(null);
                                }
                                if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
                                    loggedTypeFailures[error$1.message] = true;
                                    setCurrentlyValidatingElement(element);
                                    error("Failed %s type: %s", location, error$1.message);
                                    setCurrentlyValidatingElement(null);
                                }
                            }
                        }
                    }
                }
                var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
                var hasOwnProperty = Object.prototype.hasOwnProperty;
                var RESERVED_PROPS = {
                    key: true,
                    ref: true,
                    __self: true,
                    __source: true
                };
                var specialPropKeyWarningShown;
                var specialPropRefWarningShown;
                var didWarnAboutStringRefs;
                {
                    didWarnAboutStringRefs = {};
                }
                function hasValidRef(config) {
                    {
                        if (hasOwnProperty.call(config, "ref")) {
                            var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
                            if (getter && getter.isReactWarning) {
                                return false;
                            }
                        }
                    }
                    return config.ref !== undefined;
                }
                function hasValidKey(config) {
                    {
                        if (hasOwnProperty.call(config, "key")) {
                            var getter = Object.getOwnPropertyDescriptor(config, "key").get;
                            if (getter && getter.isReactWarning) {
                                return false;
                            }
                        }
                    }
                    return config.key !== undefined;
                }
                function warnIfStringRefCannotBeAutoConverted(config, self) {
                    {
                        if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
                            var componentName = getComponentName(ReactCurrentOwner.current.type);
                            if (!didWarnAboutStringRefs[componentName]) {
                                error('Component "%s" contains the string ref "%s". ' + "Support for string refs will be removed in a future major release. " + "This case cannot be automatically converted to an arrow function. " + "We ask you to manually fix this case by using useRef() or createRef() instead. " + "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", getComponentName(ReactCurrentOwner.current.type), config.ref);
                                didWarnAboutStringRefs[componentName] = true;
                            }
                        }
                    }
                }
                function defineKeyPropWarningGetter(props, displayName) {
                    {
                        var warnAboutAccessingKey = function() {
                            if (!specialPropKeyWarningShown) {
                                specialPropKeyWarningShown = true;
                                error("%s: `key` is not a prop. Trying to access it will result " + "in `undefined` being returned. If you need to access the same " + "value within the child component, you should pass it as a different " + "prop. (https://reactjs.org/link/special-props)", displayName);
                            }
                        };
                        warnAboutAccessingKey.isReactWarning = true;
                        Object.defineProperty(props, "key", {
                            get: warnAboutAccessingKey,
                            configurable: true
                        });
                    }
                }
                function defineRefPropWarningGetter(props, displayName) {
                    {
                        var warnAboutAccessingRef = function() {
                            if (!specialPropRefWarningShown) {
                                specialPropRefWarningShown = true;
                                error("%s: `ref` is not a prop. Trying to access it will result " + "in `undefined` being returned. If you need to access the same " + "value within the child component, you should pass it as a different " + "prop. (https://reactjs.org/link/special-props)", displayName);
                            }
                        };
                        warnAboutAccessingRef.isReactWarning = true;
                        Object.defineProperty(props, "ref", {
                            get: warnAboutAccessingRef,
                            configurable: true
                        });
                    }
                }
                var ReactElement = function(type, key, ref, self, source, owner, props) {
                    var element = {
                        $$typeof: REACT_ELEMENT_TYPE,
                        type,
                        key,
                        ref,
                        props,
                        _owner: owner
                    };
                    {
                        element._store = {};
                        Object.defineProperty(element._store, "validated", {
                            configurable: false,
                            enumerable: false,
                            writable: true,
                            value: false
                        });
                        Object.defineProperty(element, "_self", {
                            configurable: false,
                            enumerable: false,
                            writable: false,
                            value: self
                        });
                        Object.defineProperty(element, "_source", {
                            configurable: false,
                            enumerable: false,
                            writable: false,
                            value: source
                        });
                        if (Object.freeze) {
                            Object.freeze(element.props);
                            Object.freeze(element);
                        }
                    }
                    return element;
                };
                function jsxDEV(type, config, maybeKey, source, self) {
                    {
                        var propName;
                        var props = {};
                        var key = null;
                        var ref = null;
                        if (maybeKey !== undefined) {
                            key = "" + maybeKey;
                        }
                        if (hasValidKey(config)) {
                            key = "" + config.key;
                        }
                        if (hasValidRef(config)) {
                            ref = config.ref;
                            warnIfStringRefCannotBeAutoConverted(config, self);
                        }
                        for (propName in config) {
                            if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
                                props[propName] = config[propName];
                            }
                        }
                        if (type && type.defaultProps) {
                            var defaultProps = type.defaultProps;
                            for (propName in defaultProps) {
                                if (props[propName] === undefined) {
                                    props[propName] = defaultProps[propName];
                                }
                            }
                        }
                        if (key || ref) {
                            var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
                            if (key) {
                                defineKeyPropWarningGetter(props, displayName);
                            }
                            if (ref) {
                                defineRefPropWarningGetter(props, displayName);
                            }
                        }
                        return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
                    }
                }
                var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
                var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
                function setCurrentlyValidatingElement$1(element) {
                    {
                        if (element) {
                            var owner = element._owner;
                            var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
                            ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
                        } else {
                            ReactDebugCurrentFrame$1.setExtraStackFrame(null);
                        }
                    }
                }
                var propTypesMisspellWarningShown;
                {
                    propTypesMisspellWarningShown = false;
                }
                function isValidElement(object) {
                    {
                        return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
                    }
                }
                function getDeclarationErrorAddendum() {
                    {
                        if (ReactCurrentOwner$1.current) {
                            var name = getComponentName(ReactCurrentOwner$1.current.type);
                            if (name) {
                                return "\n\nCheck the render method of `" + name + "`.";
                            }
                        }
                        return "";
                    }
                }
                function getSourceInfoErrorAddendum(source) {
                    {
                        if (source !== undefined) {
                            var fileName = source.fileName.replace(/^.*[\\\/]/, "");
                            var lineNumber = source.lineNumber;
                            return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
                        }
                        return "";
                    }
                }
                var ownerHasKeyUseWarning = {};
                function getCurrentComponentErrorInfo(parentType) {
                    {
                        var info = getDeclarationErrorAddendum();
                        if (!info) {
                            var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
                            if (parentName) {
                                info = "\n\nCheck the top-level render call using <" + parentName + ">.";
                            }
                        }
                        return info;
                    }
                }
                function validateExplicitKey(element, parentType) {
                    {
                        if (!element._store || element._store.validated || element.key != null) {
                            return;
                        }
                        element._store.validated = true;
                        var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
                        if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
                            return;
                        }
                        ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
                        var childOwner = "";
                        if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
                            childOwner = " It was passed a child from " + getComponentName(element._owner.type) + ".";
                        }
                        setCurrentlyValidatingElement$1(element);
                        error('Each child in a list should have a unique "key" prop.' + "%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, childOwner);
                        setCurrentlyValidatingElement$1(null);
                    }
                }
                function validateChildKeys(node, parentType) {
                    {
                        if (typeof node !== "object") {
                            return;
                        }
                        if (Array.isArray(node)) {
                            for (var i = 0; i < node.length; i++) {
                                var child = node[i];
                                if (isValidElement(child)) {
                                    validateExplicitKey(child, parentType);
                                }
                            }
                        } else if (isValidElement(node)) {
                            if (node._store) {
                                node._store.validated = true;
                            }
                        } else if (node) {
                            var iteratorFn = getIteratorFn(node);
                            if (typeof iteratorFn === "function") {
                                if (iteratorFn !== node.entries) {
                                    var iterator = iteratorFn.call(node);
                                    var step;
                                    while (!(step = iterator.next()).done) {
                                        if (isValidElement(step.value)) {
                                            validateExplicitKey(step.value, parentType);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                function validatePropTypes(element) {
                    {
                        var type = element.type;
                        if (type === null || type === undefined || typeof type === "string") {
                            return;
                        }
                        var propTypes;
                        if (typeof type === "function") {
                            propTypes = type.propTypes;
                        } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) {
                            propTypes = type.propTypes;
                        } else {
                            return;
                        }
                        if (propTypes) {
                            var name = getComponentName(type);
                            checkPropTypes(propTypes, element.props, "prop", name, element);
                        } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
                            propTypesMisspellWarningShown = true;
                            var _name = getComponentName(type);
                            error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
                        }
                        if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
                            error("getDefaultProps is only used on classic React.createClass " + "definitions. Use a static property named `defaultProps` instead.");
                        }
                    }
                }
                function validateFragmentProps(fragment) {
                    {
                        var keys = Object.keys(fragment.props);
                        for (var i = 0; i < keys.length; i++) {
                            var key = keys[i];
                            if (key !== "children" && key !== "key") {
                                setCurrentlyValidatingElement$1(fragment);
                                error("Invalid prop `%s` supplied to `React.Fragment`. " + "React.Fragment can only have `key` and `children` props.", key);
                                setCurrentlyValidatingElement$1(null);
                                break;
                            }
                        }
                        if (fragment.ref !== null) {
                            setCurrentlyValidatingElement$1(fragment);
                            error("Invalid attribute `ref` supplied to `React.Fragment`.");
                            setCurrentlyValidatingElement$1(null);
                        }
                    }
                }
                function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
                    {
                        var validType = isValidElementType(type);
                        if (!validType) {
                            var info = "";
                            if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
                                info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and named imports.";
                            }
                            var sourceInfo = getSourceInfoErrorAddendum(source);
                            if (sourceInfo) {
                                info += sourceInfo;
                            } else {
                                info += getDeclarationErrorAddendum();
                            }
                            var typeString;
                            if (type === null) {
                                typeString = "null";
                            } else if (Array.isArray(type)) {
                                typeString = "array";
                            } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
                                typeString = "<" + (getComponentName(type.type) || "Unknown") + " />";
                                info = " Did you accidentally export a JSX literal instead of a component?";
                            } else {
                                typeString = typeof type;
                            }
                            error("React.jsx: type is invalid -- expected a string (for " + "built-in components) or a class/function (for composite " + "components) but got: %s.%s", typeString, info);
                        }
                        var element = jsxDEV(type, props, key, source, self);
                        if (element == null) {
                            return element;
                        }
                        if (validType) {
                            var children = props.children;
                            if (children !== undefined) {
                                if (isStaticChildren) {
                                    if (Array.isArray(children)) {
                                        for (var i = 0; i < children.length; i++) {
                                            validateChildKeys(children[i], type);
                                        }
                                        if (Object.freeze) {
                                            Object.freeze(children);
                                        }
                                    } else {
                                        error("React.jsx: Static children should always be an array. " + "You are likely explicitly calling React.jsxs or React.jsxDEV. " + "Use the Babel transform instead.");
                                    }
                                } else {
                                    validateChildKeys(children, type);
                                }
                            }
                        }
                        if (type === exports.Fragment) {
                            validateFragmentProps(element);
                        } else {
                            validatePropTypes(element);
                        }
                        return element;
                    }
                }
                function jsxWithValidationStatic(type, props, key) {
                    {
                        return jsxWithValidation(type, props, key, true);
                    }
                }
                function jsxWithValidationDynamic(type, props, key) {
                    {
                        return jsxWithValidation(type, props, key, false);
                    }
                }
                var jsx = jsxWithValidationDynamic;
                var jsxs = jsxWithValidationStatic;
                exports.jsx = jsx;
                exports.jsxs = jsxs;
            })();
        }
    }, module => {
        "use strict";
        module.exports = React;
    }, module => {
        "use strict";
        /*
object-assign
(c) Sindre Sorhus
@license MIT
*/        var getOwnPropertySymbols = Object.getOwnPropertySymbols;
        var hasOwnProperty = Object.prototype.hasOwnProperty;
        var propIsEnumerable = Object.prototype.propertyIsEnumerable;
        function toObject(val) {
            if (val === null || val === undefined) {
                throw new TypeError("Object.assign cannot be called with null or undefined");
            }
            return Object(val);
        }
        function shouldUseNative() {
            try {
                if (!Object.assign) {
                    return false;
                }
                var test1 = new String("abc");
                test1[5] = "de";
                if (Object.getOwnPropertyNames(test1)[0] === "5") {
                    return false;
                }
                var test2 = {};
                for (var i = 0; i < 10; i++) {
                    test2["_" + String.fromCharCode(i)] = i;
                }
                var order2 = Object.getOwnPropertyNames(test2).map((function(n) {
                    return test2[n];
                }));
                if (order2.join("") !== "0123456789") {
                    return false;
                }
                var test3 = {};
                "abcdefghijklmnopqrst".split("").forEach((function(letter) {
                    test3[letter] = letter;
                }));
                if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
                    return false;
                }
                return true;
            } catch (err) {
                return false;
            }
        }
        module.exports = shouldUseNative() ? Object.assign : function(target, source) {
            var from;
            var to = toObject(target);
            var symbols;
            for (var s = 1; s < arguments.length; s++) {
                from = Object(arguments[s]);
                for (var key in from) {
                    if (hasOwnProperty.call(from, key)) {
                        to[key] = from[key];
                    }
                }
                if (getOwnPropertySymbols) {
                    symbols = getOwnPropertySymbols(from);
                    for (var i = 0; i < symbols.length; i++) {
                        if (propIsEnumerable.call(from, symbols[i])) {
                            to[symbols[i]] = from[symbols[i]];
                        }
                    }
                }
            }
            return to;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var objectKeys = __webpack_require__(15);
        var isArguments = __webpack_require__(18);
        var is = __webpack_require__(28);
        var isRegex = __webpack_require__(34);
        var flags = __webpack_require__(35);
        var isArray = __webpack_require__(40);
        var isDate = __webpack_require__(41);
        var whichBoxedPrimitive = __webpack_require__(42);
        var GetIntrinsic = __webpack_require__(22);
        var callBound = __webpack_require__(21);
        var whichCollection = __webpack_require__(49);
        var getIterator = __webpack_require__(54);
        var getSideChannel = __webpack_require__(57);
        var whichTypedArray = __webpack_require__(60);
        var assign = __webpack_require__(66);
        var $getTime = callBound("Date.prototype.getTime");
        var gPO = Object.getPrototypeOf;
        var $objToString = callBound("Object.prototype.toString");
        var $Set = GetIntrinsic("%Set%", true);
        var $mapHas = callBound("Map.prototype.has", true);
        var $mapGet = callBound("Map.prototype.get", true);
        var $mapSize = callBound("Map.prototype.size", true);
        var $setAdd = callBound("Set.prototype.add", true);
        var $setDelete = callBound("Set.prototype.delete", true);
        var $setHas = callBound("Set.prototype.has", true);
        var $setSize = callBound("Set.prototype.size", true);
        function setHasEqualElement(set, val1, opts, channel) {
            var i = getIterator(set);
            var result;
            while ((result = i.next()) && !result.done) {
                if (internalDeepEqual(val1, result.value, opts, channel)) {
                    $setDelete(set, result.value);
                    return true;
                }
            }
            return false;
        }
        function findLooseMatchingPrimitives(prim) {
            if (typeof prim === "undefined") {
                return null;
            }
            if (typeof prim === "object") {
                return void 0;
            }
            if (typeof prim === "symbol") {
                return false;
            }
            if (typeof prim === "string" || typeof prim === "number") {
                return +prim === +prim;
            }
            return true;
        }
        function mapMightHaveLoosePrim(a, b, prim, item, opts, channel) {
            var altValue = findLooseMatchingPrimitives(prim);
            if (altValue != null) {
                return altValue;
            }
            var curB = $mapGet(b, altValue);
            var looseOpts = assign({}, opts, {
                strict: false
            });
            if (typeof curB === "undefined" && !$mapHas(b, altValue) || !internalDeepEqual(item, curB, looseOpts, channel)) {
                return false;
            }
            return !$mapHas(a, altValue) && internalDeepEqual(item, curB, looseOpts, channel);
        }
        function setMightHaveLoosePrim(a, b, prim) {
            var altValue = findLooseMatchingPrimitives(prim);
            if (altValue != null) {
                return altValue;
            }
            return $setHas(b, altValue) && !$setHas(a, altValue);
        }
        function mapHasEqualEntry(set, map, key1, item1, opts, channel) {
            var i = getIterator(set);
            var result;
            var key2;
            while ((result = i.next()) && !result.done) {
                key2 = result.value;
                if (internalDeepEqual(key1, key2, opts, channel) && internalDeepEqual(item1, $mapGet(map, key2), opts, channel)) {
                    $setDelete(set, key2);
                    return true;
                }
            }
            return false;
        }
        function internalDeepEqual(actual, expected, options, channel) {
            var opts = options || {};
            if (opts.strict ? is(actual, expected) : actual === expected) {
                return true;
            }
            var actualBoxed = whichBoxedPrimitive(actual);
            var expectedBoxed = whichBoxedPrimitive(expected);
            if (actualBoxed !== expectedBoxed) {
                return false;
            }
            if (!actual || !expected || typeof actual !== "object" && typeof expected !== "object") {
                return opts.strict ? is(actual, expected) : actual == expected;
            }
            var hasActual = channel.has(actual);
            var hasExpected = channel.has(expected);
            var sentinel;
            if (hasActual && hasExpected) {
                if (channel.get(actual) === channel.get(expected)) {
                    return true;
                }
            } else {
                sentinel = {};
            }
            if (!hasActual) {
                channel.set(actual, sentinel);
            }
            if (!hasExpected) {
                channel.set(expected, sentinel);
            }
            return objEquiv(actual, expected, opts, channel);
        }
        function isBuffer(x) {
            if (!x || typeof x !== "object" || typeof x.length !== "number") {
                return false;
            }
            if (typeof x.copy !== "function" || typeof x.slice !== "function") {
                return false;
            }
            if (x.length > 0 && typeof x[0] !== "number") {
                return false;
            }
            return !!(x.constructor && x.constructor.isBuffer && x.constructor.isBuffer(x));
        }
        function setEquiv(a, b, opts, channel) {
            if ($setSize(a) !== $setSize(b)) {
                return false;
            }
            var iA = getIterator(a);
            var iB = getIterator(b);
            var resultA;
            var resultB;
            var set;
            while ((resultA = iA.next()) && !resultA.done) {
                if (resultA.value && typeof resultA.value === "object") {
                    if (!set) {
                        set = new $Set;
                    }
                    $setAdd(set, resultA.value);
                } else if (!$setHas(b, resultA.value)) {
                    if (opts.strict) {
                        return false;
                    }
                    if (!setMightHaveLoosePrim(a, b, resultA.value)) {
                        return false;
                    }
                    if (!set) {
                        set = new $Set;
                    }
                    $setAdd(set, resultA.value);
                }
            }
            if (set) {
                while ((resultB = iB.next()) && !resultB.done) {
                    if (resultB.value && typeof resultB.value === "object") {
                        if (!setHasEqualElement(set, resultB.value, opts.strict, channel)) {
                            return false;
                        }
                    } else if (!opts.strict && !$setHas(a, resultB.value) && !setHasEqualElement(set, resultB.value, opts.strict, channel)) {
                        return false;
                    }
                }
                return $setSize(set) === 0;
            }
            return true;
        }
        function mapEquiv(a, b, opts, channel) {
            if ($mapSize(a) !== $mapSize(b)) {
                return false;
            }
            var iA = getIterator(a);
            var iB = getIterator(b);
            var resultA;
            var resultB;
            var set;
            var key;
            var item1;
            var item2;
            while ((resultA = iA.next()) && !resultA.done) {
                key = resultA.value[0];
                item1 = resultA.value[1];
                if (key && typeof key === "object") {
                    if (!set) {
                        set = new $Set;
                    }
                    $setAdd(set, key);
                } else {
                    item2 = $mapGet(b, key);
                    if (typeof item2 === "undefined" && !$mapHas(b, key) || !internalDeepEqual(item1, item2, opts, channel)) {
                        if (opts.strict) {
                            return false;
                        }
                        if (!mapMightHaveLoosePrim(a, b, key, item1, opts, channel)) {
                            return false;
                        }
                        if (!set) {
                            set = new $Set;
                        }
                        $setAdd(set, key);
                    }
                }
            }
            if (set) {
                while ((resultB = iB.next()) && !resultB.done) {
                    key = resultB.value[0];
                    item2 = resultB.value[1];
                    if (key && typeof key === "object") {
                        if (!mapHasEqualEntry(set, a, key, item2, opts, channel)) {
                            return false;
                        }
                    } else if (!opts.strict && (!a.has(key) || !internalDeepEqual($mapGet(a, key), item2, opts, channel)) && !mapHasEqualEntry(set, a, key, item2, assign({}, opts, {
                        strict: false
                    }), channel)) {
                        return false;
                    }
                }
                return $setSize(set) === 0;
            }
            return true;
        }
        function objEquiv(a, b, opts, channel) {
            var i, key;
            if (typeof a !== typeof b) {
                return false;
            }
            if (a == null || b == null) {
                return false;
            }
            if ($objToString(a) !== $objToString(b)) {
                return false;
            }
            if (isArguments(a) !== isArguments(b)) {
                return false;
            }
            var aIsArray = isArray(a);
            var bIsArray = isArray(b);
            if (aIsArray !== bIsArray) {
                return false;
            }
            var aIsError = a instanceof Error;
            var bIsError = b instanceof Error;
            if (aIsError !== bIsError) {
                return false;
            }
            if (aIsError || bIsError) {
                if (a.name !== b.name || a.message !== b.message) {
                    return false;
                }
            }
            var aIsRegex = isRegex(a);
            var bIsRegex = isRegex(b);
            if (aIsRegex !== bIsRegex) {
                return false;
            }
            if ((aIsRegex || bIsRegex) && (a.source !== b.source || flags(a) !== flags(b))) {
                return false;
            }
            var aIsDate = isDate(a);
            var bIsDate = isDate(b);
            if (aIsDate !== bIsDate) {
                return false;
            }
            if (aIsDate || bIsDate) {
                if ($getTime(a) !== $getTime(b)) {
                    return false;
                }
            }
            if (opts.strict && gPO && gPO(a) !== gPO(b)) {
                return false;
            }
            if (whichTypedArray(a) !== whichTypedArray(b)) {
                return false;
            }
            var aIsBuffer = isBuffer(a);
            var bIsBuffer = isBuffer(b);
            if (aIsBuffer !== bIsBuffer) {
                return false;
            }
            if (aIsBuffer || bIsBuffer) {
                if (a.length !== b.length) {
                    return false;
                }
                for (i = 0; i < a.length; i++) {
                    if (a[i] !== b[i]) {
                        return false;
                    }
                }
                return true;
            }
            if (typeof a !== typeof b) {
                return false;
            }
            var ka = objectKeys(a);
            var kb = objectKeys(b);
            if (ka.length !== kb.length) {
                return false;
            }
            ka.sort();
            kb.sort();
            for (i = ka.length - 1; i >= 0; i--) {
                if (ka[i] != kb[i]) {
                    return false;
                }
            }
            for (i = ka.length - 1; i >= 0; i--) {
                key = ka[i];
                if (!internalDeepEqual(a[key], b[key], opts, channel)) {
                    return false;
                }
            }
            var aCollection = whichCollection(a);
            var bCollection = whichCollection(b);
            if (aCollection !== bCollection) {
                return false;
            }
            if (aCollection === "Set" || bCollection === "Set") {
                return setEquiv(a, b, opts, channel);
            }
            if (aCollection === "Map") {
                return mapEquiv(a, b, opts, channel);
            }
            return true;
        }
        module.exports = function deepEqual(a, b, opts) {
            return internalDeepEqual(a, b, opts, getSideChannel());
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var slice = Array.prototype.slice;
        var isArgs = __webpack_require__(16);
        var origKeys = Object.keys;
        var keysShim = origKeys ? function keys(o) {
            return origKeys(o);
        } : __webpack_require__(17);
        var originalKeys = Object.keys;
        keysShim.shim = function shimObjectKeys() {
            if (Object.keys) {
                var keysWorksWithArguments = function() {
                    var args = Object.keys(arguments);
                    return args && args.length === arguments.length;
                }(1, 2);
                if (!keysWorksWithArguments) {
                    Object.keys = function keys(object) {
                        if (isArgs(object)) {
                            return originalKeys(slice.call(object));
                        }
                        return originalKeys(object);
                    };
                }
            } else {
                Object.keys = keysShim;
            }
            return Object.keys || keysShim;
        };
        module.exports = keysShim;
    }, module => {
        "use strict";
        var toStr = Object.prototype.toString;
        module.exports = function isArguments(value) {
            var str = toStr.call(value);
            var isArgs = str === "[object Arguments]";
            if (!isArgs) {
                isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
            }
            return isArgs;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var keysShim;
        if (!Object.keys) {
            var has = Object.prototype.hasOwnProperty;
            var toStr = Object.prototype.toString;
            var isArgs = __webpack_require__(16);
            var isEnumerable = Object.prototype.propertyIsEnumerable;
            var hasDontEnumBug = !isEnumerable.call({
                toString: null
            }, "toString");
            var hasProtoEnumBug = isEnumerable.call((function() {}), "prototype");
            var dontEnums = [ "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor" ];
            var equalsConstructorPrototype = function(o) {
                var ctor = o.constructor;
                return ctor && ctor.prototype === o;
            };
            var excludedKeys = {
                $applicationCache: true,
                $console: true,
                $external: true,
                $frame: true,
                $frameElement: true,
                $frames: true,
                $innerHeight: true,
                $innerWidth: true,
                $onmozfullscreenchange: true,
                $onmozfullscreenerror: true,
                $outerHeight: true,
                $outerWidth: true,
                $pageXOffset: true,
                $pageYOffset: true,
                $parent: true,
                $scrollLeft: true,
                $scrollTop: true,
                $scrollX: true,
                $scrollY: true,
                $self: true,
                $webkitIndexedDB: true,
                $webkitStorageInfo: true,
                $window: true
            };
            var hasAutomationEqualityBug = function() {
                if (typeof window === "undefined") {
                    return false;
                }
                for (var k in window) {
                    try {
                        if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
                            try {
                                equalsConstructorPrototype(window[k]);
                            } catch (e) {
                                return true;
                            }
                        }
                    } catch (e) {
                        return true;
                    }
                }
                return false;
            }();
            var equalsConstructorPrototypeIfNotBuggy = function(o) {
                if (typeof window === "undefined" || !hasAutomationEqualityBug) {
                    return equalsConstructorPrototype(o);
                }
                try {
                    return equalsConstructorPrototype(o);
                } catch (e) {
                    return false;
                }
            };
            keysShim = function keys(object) {
                var isObject = object !== null && typeof object === "object";
                var isFunction = toStr.call(object) === "[object Function]";
                var isArguments = isArgs(object);
                var isString = isObject && toStr.call(object) === "[object String]";
                var theKeys = [];
                if (!isObject && !isFunction && !isArguments) {
                    throw new TypeError("Object.keys called on a non-object");
                }
                var skipProto = hasProtoEnumBug && isFunction;
                if (isString && object.length > 0 && !has.call(object, 0)) {
                    for (var i = 0; i < object.length; ++i) {
                        theKeys.push(String(i));
                    }
                }
                if (isArguments && object.length > 0) {
                    for (var j = 0; j < object.length; ++j) {
                        theKeys.push(String(j));
                    }
                } else {
                    for (var name in object) {
                        if (!(skipProto && name === "prototype") && has.call(object, name)) {
                            theKeys.push(String(name));
                        }
                    }
                }
                if (hasDontEnumBug) {
                    var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
                    for (var k = 0; k < dontEnums.length; ++k) {
                        if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
                            theKeys.push(dontEnums[k]);
                        }
                    }
                }
                return theKeys;
            };
        }
        module.exports = keysShim;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var hasToStringTag = __webpack_require__(19)();
        var callBound = __webpack_require__(21);
        var $toString = callBound("Object.prototype.toString");
        var isStandardArguments = function isArguments(value) {
            if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) {
                return false;
            }
            return $toString(value) === "[object Arguments]";
        };
        var isLegacyArguments = function isArguments(value) {
            if (isStandardArguments(value)) {
                return true;
            }
            return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && $toString(value.callee) === "[object Function]";
        };
        var supportsStandardArguments = function() {
            return isStandardArguments(arguments);
        }();
        isStandardArguments.isLegacyArguments = isLegacyArguments;
        module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var hasSymbols = __webpack_require__(20);
        module.exports = function hasToStringTagShams() {
            return hasSymbols() && !!Symbol.toStringTag;
        };
    }, module => {
        "use strict";
        module.exports = function hasSymbols() {
            if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
                return false;
            }
            if (typeof Symbol.iterator === "symbol") {
                return true;
            }
            var obj = {};
            var sym = Symbol("test");
            var symObj = Object(sym);
            if (typeof sym === "string") {
                return false;
            }
            if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
                return false;
            }
            if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
                return false;
            }
            var symVal = 42;
            obj[sym] = symVal;
            for (sym in obj) {
                return false;
            }
            if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
                return false;
            }
            if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
                return false;
            }
            var syms = Object.getOwnPropertySymbols(obj);
            if (syms.length !== 1 || syms[0] !== sym) {
                return false;
            }
            if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
                return false;
            }
            if (typeof Object.getOwnPropertyDescriptor === "function") {
                var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
                if (descriptor.value !== symVal || descriptor.enumerable !== true) {
                    return false;
                }
            }
            return true;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var callBind = __webpack_require__(27);
        var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
        module.exports = function callBoundIntrinsic(name, allowMissing) {
            var intrinsic = GetIntrinsic(name, !!allowMissing);
            if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
                return callBind(intrinsic);
            }
            return intrinsic;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var undefined;
        var $SyntaxError = SyntaxError;
        var $Function = Function;
        var $TypeError = TypeError;
        var getEvalledConstructor = function(expressionSyntax) {
            try {
                return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
            } catch (e) {}
        };
        var $gOPD = Object.getOwnPropertyDescriptor;
        if ($gOPD) {
            try {
                $gOPD({}, "");
            } catch (e) {
                $gOPD = null;
            }
        }
        var throwTypeError = function() {
            throw new $TypeError;
        };
        var ThrowTypeError = $gOPD ? function() {
            try {
                arguments.callee;
                return throwTypeError;
            } catch (calleeThrows) {
                try {
                    return $gOPD(arguments, "callee").get;
                } catch (gOPDthrows) {
                    return throwTypeError;
                }
            }
        }() : throwTypeError;
        var hasSymbols = __webpack_require__(23)();
        var getProto = Object.getPrototypeOf || function(x) {
            return x.__proto__;
        };
        var needsEval = {};
        var TypedArray = typeof Uint8Array === "undefined" ? undefined : getProto(Uint8Array);
        var INTRINSICS = {
            "%AggregateError%": typeof AggregateError === "undefined" ? undefined : AggregateError,
            "%Array%": Array,
            "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined : ArrayBuffer,
            "%ArrayIteratorPrototype%": hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
            "%AsyncFromSyncIteratorPrototype%": undefined,
            "%AsyncFunction%": needsEval,
            "%AsyncGenerator%": needsEval,
            "%AsyncGeneratorFunction%": needsEval,
            "%AsyncIteratorPrototype%": needsEval,
            "%Atomics%": typeof Atomics === "undefined" ? undefined : Atomics,
            "%BigInt%": typeof BigInt === "undefined" ? undefined : BigInt,
            "%Boolean%": Boolean,
            "%DataView%": typeof DataView === "undefined" ? undefined : DataView,
            "%Date%": Date,
            "%decodeURI%": decodeURI,
            "%decodeURIComponent%": decodeURIComponent,
            "%encodeURI%": encodeURI,
            "%encodeURIComponent%": encodeURIComponent,
            "%Error%": Error,
            "%eval%": eval,
            "%EvalError%": EvalError,
            "%Float32Array%": typeof Float32Array === "undefined" ? undefined : Float32Array,
            "%Float64Array%": typeof Float64Array === "undefined" ? undefined : Float64Array,
            "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined : FinalizationRegistry,
            "%Function%": $Function,
            "%GeneratorFunction%": needsEval,
            "%Int8Array%": typeof Int8Array === "undefined" ? undefined : Int8Array,
            "%Int16Array%": typeof Int16Array === "undefined" ? undefined : Int16Array,
            "%Int32Array%": typeof Int32Array === "undefined" ? undefined : Int32Array,
            "%isFinite%": isFinite,
            "%isNaN%": isNaN,
            "%IteratorPrototype%": hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
            "%JSON%": typeof JSON === "object" ? JSON : undefined,
            "%Map%": typeof Map === "undefined" ? undefined : Map,
            "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols ? undefined : getProto((new Map)[Symbol.iterator]()),
            "%Math%": Math,
            "%Number%": Number,
            "%Object%": Object,
            "%parseFloat%": parseFloat,
            "%parseInt%": parseInt,
            "%Promise%": typeof Promise === "undefined" ? undefined : Promise,
            "%Proxy%": typeof Proxy === "undefined" ? undefined : Proxy,
            "%RangeError%": RangeError,
            "%ReferenceError%": ReferenceError,
            "%Reflect%": typeof Reflect === "undefined" ? undefined : Reflect,
            "%RegExp%": RegExp,
            "%Set%": typeof Set === "undefined" ? undefined : Set,
            "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols ? undefined : getProto((new Set)[Symbol.iterator]()),
            "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined : SharedArrayBuffer,
            "%String%": String,
            "%StringIteratorPrototype%": hasSymbols ? getProto(""[Symbol.iterator]()) : undefined,
            "%Symbol%": hasSymbols ? Symbol : undefined,
            "%SyntaxError%": $SyntaxError,
            "%ThrowTypeError%": ThrowTypeError,
            "%TypedArray%": TypedArray,
            "%TypeError%": $TypeError,
            "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined : Uint8Array,
            "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined : Uint8ClampedArray,
            "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined : Uint16Array,
            "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined : Uint32Array,
            "%URIError%": URIError,
            "%WeakMap%": typeof WeakMap === "undefined" ? undefined : WeakMap,
            "%WeakRef%": typeof WeakRef === "undefined" ? undefined : WeakRef,
            "%WeakSet%": typeof WeakSet === "undefined" ? undefined : WeakSet
        };
        var doEval = function doEval(name) {
            var value;
            if (name === "%AsyncFunction%") {
                value = getEvalledConstructor("async function () {}");
            } else if (name === "%GeneratorFunction%") {
                value = getEvalledConstructor("function* () {}");
            } else if (name === "%AsyncGeneratorFunction%") {
                value = getEvalledConstructor("async function* () {}");
            } else if (name === "%AsyncGenerator%") {
                var fn = doEval("%AsyncGeneratorFunction%");
                if (fn) {
                    value = fn.prototype;
                }
            } else if (name === "%AsyncIteratorPrototype%") {
                var gen = doEval("%AsyncGenerator%");
                if (gen) {
                    value = getProto(gen.prototype);
                }
            }
            INTRINSICS[name] = value;
            return value;
        };
        var LEGACY_ALIASES = {
            "%ArrayBufferPrototype%": [ "ArrayBuffer", "prototype" ],
            "%ArrayPrototype%": [ "Array", "prototype" ],
            "%ArrayProto_entries%": [ "Array", "prototype", "entries" ],
            "%ArrayProto_forEach%": [ "Array", "prototype", "forEach" ],
            "%ArrayProto_keys%": [ "Array", "prototype", "keys" ],
            "%ArrayProto_values%": [ "Array", "prototype", "values" ],
            "%AsyncFunctionPrototype%": [ "AsyncFunction", "prototype" ],
            "%AsyncGenerator%": [ "AsyncGeneratorFunction", "prototype" ],
            "%AsyncGeneratorPrototype%": [ "AsyncGeneratorFunction", "prototype", "prototype" ],
            "%BooleanPrototype%": [ "Boolean", "prototype" ],
            "%DataViewPrototype%": [ "DataView", "prototype" ],
            "%DatePrototype%": [ "Date", "prototype" ],
            "%ErrorPrototype%": [ "Error", "prototype" ],
            "%EvalErrorPrototype%": [ "EvalError", "prototype" ],
            "%Float32ArrayPrototype%": [ "Float32Array", "prototype" ],
            "%Float64ArrayPrototype%": [ "Float64Array", "prototype" ],
            "%FunctionPrototype%": [ "Function", "prototype" ],
            "%Generator%": [ "GeneratorFunction", "prototype" ],
            "%GeneratorPrototype%": [ "GeneratorFunction", "prototype", "prototype" ],
            "%Int8ArrayPrototype%": [ "Int8Array", "prototype" ],
            "%Int16ArrayPrototype%": [ "Int16Array", "prototype" ],
            "%Int32ArrayPrototype%": [ "Int32Array", "prototype" ],
            "%JSONParse%": [ "JSON", "parse" ],
            "%JSONStringify%": [ "JSON", "stringify" ],
            "%MapPrototype%": [ "Map", "prototype" ],
            "%NumberPrototype%": [ "Number", "prototype" ],
            "%ObjectPrototype%": [ "Object", "prototype" ],
            "%ObjProto_toString%": [ "Object", "prototype", "toString" ],
            "%ObjProto_valueOf%": [ "Object", "prototype", "valueOf" ],
            "%PromisePrototype%": [ "Promise", "prototype" ],
            "%PromiseProto_then%": [ "Promise", "prototype", "then" ],
            "%Promise_all%": [ "Promise", "all" ],
            "%Promise_reject%": [ "Promise", "reject" ],
            "%Promise_resolve%": [ "Promise", "resolve" ],
            "%RangeErrorPrototype%": [ "RangeError", "prototype" ],
            "%ReferenceErrorPrototype%": [ "ReferenceError", "prototype" ],
            "%RegExpPrototype%": [ "RegExp", "prototype" ],
            "%SetPrototype%": [ "Set", "prototype" ],
            "%SharedArrayBufferPrototype%": [ "SharedArrayBuffer", "prototype" ],
            "%StringPrototype%": [ "String", "prototype" ],
            "%SymbolPrototype%": [ "Symbol", "prototype" ],
            "%SyntaxErrorPrototype%": [ "SyntaxError", "prototype" ],
            "%TypedArrayPrototype%": [ "TypedArray", "prototype" ],
            "%TypeErrorPrototype%": [ "TypeError", "prototype" ],
            "%Uint8ArrayPrototype%": [ "Uint8Array", "prototype" ],
            "%Uint8ClampedArrayPrototype%": [ "Uint8ClampedArray", "prototype" ],
            "%Uint16ArrayPrototype%": [ "Uint16Array", "prototype" ],
            "%Uint32ArrayPrototype%": [ "Uint32Array", "prototype" ],
            "%URIErrorPrototype%": [ "URIError", "prototype" ],
            "%WeakMapPrototype%": [ "WeakMap", "prototype" ],
            "%WeakSetPrototype%": [ "WeakSet", "prototype" ]
        };
        var bind = __webpack_require__(24);
        var hasOwn = __webpack_require__(26);
        var $concat = bind.call(Function.call, Array.prototype.concat);
        var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
        var $replace = bind.call(Function.call, String.prototype.replace);
        var $strSlice = bind.call(Function.call, String.prototype.slice);
        var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
        var reEscapeChar = /\\(\\)?/g;
        var stringToPath = function stringToPath(string) {
            var first = $strSlice(string, 0, 1);
            var last = $strSlice(string, -1);
            if (first === "%" && last !== "%") {
                throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
            } else if (last === "%" && first !== "%") {
                throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
            }
            var result = [];
            $replace(string, rePropName, (function(match, number, quote, subString) {
                result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
            }));
            return result;
        };
        var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
            var intrinsicName = name;
            var alias;
            if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
                alias = LEGACY_ALIASES[intrinsicName];
                intrinsicName = "%" + alias[0] + "%";
            }
            if (hasOwn(INTRINSICS, intrinsicName)) {
                var value = INTRINSICS[intrinsicName];
                if (value === needsEval) {
                    value = doEval(intrinsicName);
                }
                if (typeof value === "undefined" && !allowMissing) {
                    throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
                }
                return {
                    alias,
                    name: intrinsicName,
                    value
                };
            }
            throw new $SyntaxError("intrinsic " + name + " does not exist!");
        };
        module.exports = function GetIntrinsic(name, allowMissing) {
            if (typeof name !== "string" || name.length === 0) {
                throw new $TypeError("intrinsic name must be a non-empty string");
            }
            if (arguments.length > 1 && typeof allowMissing !== "boolean") {
                throw new $TypeError('"allowMissing" argument must be a boolean');
            }
            var parts = stringToPath(name);
            var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
            var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
            var intrinsicRealName = intrinsic.name;
            var value = intrinsic.value;
            var skipFurtherCaching = false;
            var alias = intrinsic.alias;
            if (alias) {
                intrinsicBaseName = alias[0];
                $spliceApply(parts, $concat([ 0, 1 ], alias));
            }
            for (var i = 1, isOwn = true; i < parts.length; i += 1) {
                var part = parts[i];
                var first = $strSlice(part, 0, 1);
                var last = $strSlice(part, -1);
                if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
                    throw new $SyntaxError("property names with quotes must have matching quotes");
                }
                if (part === "constructor" || !isOwn) {
                    skipFurtherCaching = true;
                }
                intrinsicBaseName += "." + part;
                intrinsicRealName = "%" + intrinsicBaseName + "%";
                if (hasOwn(INTRINSICS, intrinsicRealName)) {
                    value = INTRINSICS[intrinsicRealName];
                } else if (value != null) {
                    if (!(part in value)) {
                        if (!allowMissing) {
                            throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
                        }
                        return void undefined;
                    }
                    if ($gOPD && i + 1 >= parts.length) {
                        var desc = $gOPD(value, part);
                        isOwn = !!desc;
                        if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
                            value = desc.get;
                        } else {
                            value = value[part];
                        }
                    } else {
                        isOwn = hasOwn(value, part);
                        value = value[part];
                    }
                    if (isOwn && !skipFurtherCaching) {
                        INTRINSICS[intrinsicRealName] = value;
                    }
                }
            }
            return value;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var origSymbol = typeof Symbol !== "undefined" && Symbol;
        var hasSymbolSham = __webpack_require__(20);
        module.exports = function hasNativeSymbols() {
            if (typeof origSymbol !== "function") {
                return false;
            }
            if (typeof Symbol !== "function") {
                return false;
            }
            if (typeof origSymbol("foo") !== "symbol") {
                return false;
            }
            if (typeof Symbol("bar") !== "symbol") {
                return false;
            }
            return hasSymbolSham();
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(25);
        module.exports = Function.prototype.bind || implementation;
    }, module => {
        "use strict";
        var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
        var slice = Array.prototype.slice;
        var toStr = Object.prototype.toString;
        var funcType = "[object Function]";
        module.exports = function bind(that) {
            var target = this;
            if (typeof target !== "function" || toStr.call(target) !== funcType) {
                throw new TypeError(ERROR_MESSAGE + target);
            }
            var args = slice.call(arguments, 1);
            var bound;
            var binder = function() {
                if (this instanceof bound) {
                    var result = target.apply(this, args.concat(slice.call(arguments)));
                    if (Object(result) === result) {
                        return result;
                    }
                    return this;
                } else {
                    return target.apply(that, args.concat(slice.call(arguments)));
                }
            };
            var boundLength = Math.max(0, target.length - args.length);
            var boundArgs = [];
            for (var i = 0; i < boundLength; i++) {
                boundArgs.push("$" + i);
            }
            bound = Function("binder", "return function (" + boundArgs.join(",") + "){ return binder.apply(this,arguments); }")(binder);
            if (target.prototype) {
                var Empty = function Empty() {};
                Empty.prototype = target.prototype;
                bound.prototype = new Empty;
                Empty.prototype = null;
            }
            return bound;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var bind = __webpack_require__(24);
        module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var bind = __webpack_require__(24);
        var GetIntrinsic = __webpack_require__(22);
        var $apply = GetIntrinsic("%Function.prototype.apply%");
        var $call = GetIntrinsic("%Function.prototype.call%");
        var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
        var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
        var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
        var $max = GetIntrinsic("%Math.max%");
        if ($defineProperty) {
            try {
                $defineProperty({}, "a", {
                    value: 1
                });
            } catch (e) {
                $defineProperty = null;
            }
        }
        module.exports = function callBind(originalFunction) {
            var func = $reflectApply(bind, $call, arguments);
            if ($gOPD && $defineProperty) {
                var desc = $gOPD(func, "length");
                if (desc.configurable) {
                    $defineProperty(func, "length", {
                        value: 1 + $max(0, originalFunction.length - (arguments.length - 1))
                    });
                }
            }
            return func;
        };
        var applyBind = function applyBind() {
            return $reflectApply(bind, $apply, arguments);
        };
        if ($defineProperty) {
            $defineProperty(module.exports, "apply", {
                value: applyBind
            });
        } else {
            module.exports.apply = applyBind;
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var callBind = __webpack_require__(27);
        var implementation = __webpack_require__(31);
        var getPolyfill = __webpack_require__(32);
        var shim = __webpack_require__(33);
        var polyfill = callBind(getPolyfill(), Object);
        define(polyfill, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = polyfill;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var keys = __webpack_require__(15);
        var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
        var toStr = Object.prototype.toString;
        var concat = Array.prototype.concat;
        var origDefineProperty = Object.defineProperty;
        var isFunction = function(fn) {
            return typeof fn === "function" && toStr.call(fn) === "[object Function]";
        };
        var hasPropertyDescriptors = __webpack_require__(30)();
        var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
        var defineProperty = function(object, name, value, predicate) {
            if (name in object && (!isFunction(predicate) || !predicate())) {
                return;
            }
            if (supportsDescriptors) {
                origDefineProperty(object, name, {
                    configurable: true,
                    enumerable: false,
                    value,
                    writable: true
                });
            } else {
                object[name] = value;
            }
        };
        var defineProperties = function(object, map) {
            var predicates = arguments.length > 2 ? arguments[2] : {};
            var props = keys(map);
            if (hasSymbols) {
                props = concat.call(props, Object.getOwnPropertySymbols(map));
            }
            for (var i = 0; i < props.length; i += 1) {
                defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
            }
        };
        defineProperties.supportsDescriptors = !!supportsDescriptors;
        module.exports = defineProperties;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
        var hasPropertyDescriptors = function hasPropertyDescriptors() {
            if ($defineProperty) {
                try {
                    $defineProperty({}, "a", {
                        value: 1
                    });
                    return true;
                } catch (e) {
                    return false;
                }
            }
            return false;
        };
        hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
            if (!hasPropertyDescriptors()) {
                return null;
            }
            try {
                return $defineProperty([], "length", {
                    value: 1
                }).length !== 1;
            } catch (e) {
                return true;
            }
        };
        module.exports = hasPropertyDescriptors;
    }, module => {
        "use strict";
        var numberIsNaN = function(value) {
            return value !== value;
        };
        module.exports = function is(a, b) {
            if (a === 0 && b === 0) {
                return 1 / a === 1 / b;
            }
            if (a === b) {
                return true;
            }
            if (numberIsNaN(a) && numberIsNaN(b)) {
                return true;
            }
            return false;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(31);
        module.exports = function getPolyfill() {
            return typeof Object.is === "function" ? Object.is : implementation;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var getPolyfill = __webpack_require__(32);
        var define = __webpack_require__(29);
        module.exports = function shimObjectIs() {
            var polyfill = getPolyfill();
            define(Object, {
                is: polyfill
            }, {
                is: function testObjectIs() {
                    return Object.is !== polyfill;
                }
            });
            return polyfill;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var callBound = __webpack_require__(21);
        var hasToStringTag = __webpack_require__(19)();
        var has;
        var $exec;
        var isRegexMarker;
        var badStringifier;
        if (hasToStringTag) {
            has = callBound("Object.prototype.hasOwnProperty");
            $exec = callBound("RegExp.prototype.exec");
            isRegexMarker = {};
            var throwRegexMarker = function() {
                throw isRegexMarker;
            };
            badStringifier = {
                toString: throwRegexMarker,
                valueOf: throwRegexMarker
            };
            if (typeof Symbol.toPrimitive === "symbol") {
                badStringifier[Symbol.toPrimitive] = throwRegexMarker;
            }
        }
        var $toString = callBound("Object.prototype.toString");
        var gOPD = Object.getOwnPropertyDescriptor;
        var regexClass = "[object RegExp]";
        module.exports = hasToStringTag ? function isRegex(value) {
            if (!value || typeof value !== "object") {
                return false;
            }
            var descriptor = gOPD(value, "lastIndex");
            var hasLastIndexDataProperty = descriptor && has(descriptor, "value");
            if (!hasLastIndexDataProperty) {
                return false;
            }
            try {
                $exec(value, badStringifier);
            } catch (e) {
                return e === isRegexMarker;
            }
        } : function isRegex(value) {
            if (!value || typeof value !== "object" && typeof value !== "function") {
                return false;
            }
            return $toString(value) === regexClass;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var callBind = __webpack_require__(27);
        var implementation = __webpack_require__(36);
        var getPolyfill = __webpack_require__(38);
        var shim = __webpack_require__(39);
        var flagsBound = callBind(getPolyfill());
        define(flagsBound, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = flagsBound;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var functionsHaveConfigurableNames = __webpack_require__(37).functionsHaveConfigurableNames();
        var $Object = Object;
        var $TypeError = TypeError;
        module.exports = function flags() {
            if (this != null && this !== $Object(this)) {
                throw new $TypeError("RegExp.prototype.flags getter called on non-object");
            }
            var result = "";
            if (this.hasIndices) {
                result += "d";
            }
            if (this.global) {
                result += "g";
            }
            if (this.ignoreCase) {
                result += "i";
            }
            if (this.multiline) {
                result += "m";
            }
            if (this.dotAll) {
                result += "s";
            }
            if (this.unicode) {
                result += "u";
            }
            if (this.sticky) {
                result += "y";
            }
            return result;
        };
        if (functionsHaveConfigurableNames && Object.defineProperty) {
            Object.defineProperty(module.exports, "name", {
                value: "get flags"
            });
        }
    }, module => {
        "use strict";
        var functionsHaveNames = function functionsHaveNames() {
            return typeof function f() {}.name === "string";
        };
        var gOPD = Object.getOwnPropertyDescriptor;
        if (gOPD) {
            try {
                gOPD([], "length");
            } catch (e) {
                gOPD = null;
            }
        }
        functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {
            if (!functionsHaveNames() || !gOPD) {
                return false;
            }
            var desc = gOPD((function() {}), "name");
            return !!desc && !!desc.configurable;
        };
        var $bind = Function.prototype.bind;
        functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {
            return functionsHaveNames() && typeof $bind === "function" && function f() {}.bind().name !== "";
        };
        module.exports = functionsHaveNames;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(36);
        var supportsDescriptors = __webpack_require__(29).supportsDescriptors;
        var $gOPD = Object.getOwnPropertyDescriptor;
        module.exports = function getPolyfill() {
            if (supportsDescriptors && /a/gim.flags === "gim") {
                var descriptor = $gOPD(RegExp.prototype, "flags");
                if (descriptor && typeof descriptor.get === "function" && typeof RegExp.prototype.dotAll === "boolean" && typeof RegExp.prototype.hasIndices === "boolean") {
                    var calls = "";
                    var o = {};
                    Object.defineProperty(o, "hasIndices", {
                        get: function() {
                            calls += "d";
                        }
                    });
                    Object.defineProperty(o, "sticky", {
                        get: function() {
                            calls += "y";
                        }
                    });
                    if (calls === "dy") {
                        return descriptor.get;
                    }
                }
            }
            return implementation;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var supportsDescriptors = __webpack_require__(29).supportsDescriptors;
        var getPolyfill = __webpack_require__(38);
        var gOPD = Object.getOwnPropertyDescriptor;
        var defineProperty = Object.defineProperty;
        var TypeErr = TypeError;
        var getProto = Object.getPrototypeOf;
        var regex = /a/;
        module.exports = function shimFlags() {
            if (!supportsDescriptors || !getProto) {
                throw new TypeErr("RegExp.prototype.flags requires a true ES5 environment that supports property descriptors");
            }
            var polyfill = getPolyfill();
            var proto = getProto(regex);
            var descriptor = gOPD(proto, "flags");
            if (!descriptor || descriptor.get !== polyfill) {
                defineProperty(proto, "flags", {
                    configurable: true,
                    enumerable: false,
                    get: polyfill
                });
            }
            return polyfill;
        };
    }, module => {
        var toString = {}.toString;
        module.exports = Array.isArray || function(arr) {
            return toString.call(arr) == "[object Array]";
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var getDay = Date.prototype.getDay;
        var tryDateObject = function tryDateGetDayCall(value) {
            try {
                getDay.call(value);
                return true;
            } catch (e) {
                return false;
            }
        };
        var toStr = Object.prototype.toString;
        var dateClass = "[object Date]";
        var hasToStringTag = __webpack_require__(19)();
        module.exports = function isDateObject(value) {
            if (typeof value !== "object" || value === null) {
                return false;
            }
            return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var isString = __webpack_require__(43);
        var isNumber = __webpack_require__(44);
        var isBoolean = __webpack_require__(45);
        var isSymbol = __webpack_require__(46);
        var isBigInt = __webpack_require__(47);
        module.exports = function whichBoxedPrimitive(value) {
            if (value == null || typeof value !== "object" && typeof value !== "function") {
                return null;
            }
            if (isString(value)) {
                return "String";
            }
            if (isNumber(value)) {
                return "Number";
            }
            if (isBoolean(value)) {
                return "Boolean";
            }
            if (isSymbol(value)) {
                return "Symbol";
            }
            if (isBigInt(value)) {
                return "BigInt";
            }
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var strValue = String.prototype.valueOf;
        var tryStringObject = function tryStringObject(value) {
            try {
                strValue.call(value);
                return true;
            } catch (e) {
                return false;
            }
        };
        var toStr = Object.prototype.toString;
        var strClass = "[object String]";
        var hasToStringTag = __webpack_require__(19)();
        module.exports = function isString(value) {
            if (typeof value === "string") {
                return true;
            }
            if (typeof value !== "object") {
                return false;
            }
            return hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var numToStr = Number.prototype.toString;
        var tryNumberObject = function tryNumberObject(value) {
            try {
                numToStr.call(value);
                return true;
            } catch (e) {
                return false;
            }
        };
        var toStr = Object.prototype.toString;
        var numClass = "[object Number]";
        var hasToStringTag = __webpack_require__(19)();
        module.exports = function isNumberObject(value) {
            if (typeof value === "number") {
                return true;
            }
            if (typeof value !== "object") {
                return false;
            }
            return hasToStringTag ? tryNumberObject(value) : toStr.call(value) === numClass;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var callBound = __webpack_require__(21);
        var $boolToStr = callBound("Boolean.prototype.toString");
        var $toString = callBound("Object.prototype.toString");
        var tryBooleanObject = function booleanBrandCheck(value) {
            try {
                $boolToStr(value);
                return true;
            } catch (e) {
                return false;
            }
        };
        var boolClass = "[object Boolean]";
        var hasToStringTag = __webpack_require__(19)();
        module.exports = function isBoolean(value) {
            if (typeof value === "boolean") {
                return true;
            }
            if (value === null || typeof value !== "object") {
                return false;
            }
            return hasToStringTag && Symbol.toStringTag in value ? tryBooleanObject(value) : $toString(value) === boolClass;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var toStr = Object.prototype.toString;
        var hasSymbols = __webpack_require__(23)();
        if (hasSymbols) {
            var symToStr = Symbol.prototype.toString;
            var symStringRegex = /^Symbol\(.*\)$/;
            var isSymbolObject = function isRealSymbolObject(value) {
                if (typeof value.valueOf() !== "symbol") {
                    return false;
                }
                return symStringRegex.test(symToStr.call(value));
            };
            module.exports = function isSymbol(value) {
                if (typeof value === "symbol") {
                    return true;
                }
                if (toStr.call(value) !== "[object Symbol]") {
                    return false;
                }
                try {
                    return isSymbolObject(value);
                } catch (e) {
                    return false;
                }
            };
        } else {
            module.exports = function isSymbol(value) {
                return false && 0;
            };
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var hasBigInts = __webpack_require__(48)();
        if (hasBigInts) {
            var bigIntValueOf = BigInt.prototype.valueOf;
            var tryBigInt = function tryBigIntObject(value) {
                try {
                    bigIntValueOf.call(value);
                    return true;
                } catch (e) {}
                return false;
            };
            module.exports = function isBigInt(value) {
                if (value === null || typeof value === "undefined" || typeof value === "boolean" || typeof value === "string" || typeof value === "number" || typeof value === "symbol" || typeof value === "function") {
                    return false;
                }
                if (typeof value === "bigint") {
                    return true;
                }
                return tryBigInt(value);
            };
        } else {
            module.exports = function isBigInt(value) {
                return false && 0;
            };
        }
    }, module => {
        "use strict";
        var $BigInt = typeof BigInt !== "undefined" && BigInt;
        module.exports = function hasNativeBigInts() {
            return typeof $BigInt === "function" && typeof BigInt === "function" && typeof $BigInt(42) === "bigint" && typeof BigInt(42) === "bigint";
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var isMap = __webpack_require__(50);
        var isSet = __webpack_require__(51);
        var isWeakMap = __webpack_require__(52);
        var isWeakSet = __webpack_require__(53);
        module.exports = function whichCollection(value) {
            if (value && typeof value === "object") {
                if (isMap(value)) {
                    return "Map";
                }
                if (isSet(value)) {
                    return "Set";
                }
                if (isWeakMap(value)) {
                    return "WeakMap";
                }
                if (isWeakSet(value)) {
                    return "WeakSet";
                }
            }
            return false;
        };
    }, module => {
        "use strict";
        var $Map = typeof Map === "function" && Map.prototype ? Map : null;
        var $Set = typeof Set === "function" && Set.prototype ? Set : null;
        var exported;
        if (!$Map) {
            exported = function isMap(x) {
                return false;
            };
        }
        var $mapHas = $Map ? Map.prototype.has : null;
        var $setHas = $Set ? Set.prototype.has : null;
        if (!exported && !$mapHas) {
            exported = function isMap(x) {
                return false;
            };
        }
        module.exports = exported || function isMap(x) {
            if (!x || typeof x !== "object") {
                return false;
            }
            try {
                $mapHas.call(x);
                if ($setHas) {
                    try {
                        $setHas.call(x);
                    } catch (e) {
                        return true;
                    }
                }
                return x instanceof $Map;
            } catch (e) {}
            return false;
        };
    }, module => {
        "use strict";
        var $Map = typeof Map === "function" && Map.prototype ? Map : null;
        var $Set = typeof Set === "function" && Set.prototype ? Set : null;
        var exported;
        if (!$Set) {
            exported = function isSet(x) {
                return false;
            };
        }
        var $mapHas = $Map ? Map.prototype.has : null;
        var $setHas = $Set ? Set.prototype.has : null;
        if (!exported && !$setHas) {
            exported = function isSet(x) {
                return false;
            };
        }
        module.exports = exported || function isSet(x) {
            if (!x || typeof x !== "object") {
                return false;
            }
            try {
                $setHas.call(x);
                if ($mapHas) {
                    try {
                        $mapHas.call(x);
                    } catch (e) {
                        return true;
                    }
                }
                return x instanceof $Set;
            } catch (e) {}
            return false;
        };
    }, module => {
        "use strict";
        var $WeakMap = typeof WeakMap === "function" && WeakMap.prototype ? WeakMap : null;
        var $WeakSet = typeof WeakSet === "function" && WeakSet.prototype ? WeakSet : null;
        var exported;
        if (!$WeakMap) {
            exported = function isWeakMap(x) {
                return false;
            };
        }
        var $mapHas = $WeakMap ? $WeakMap.prototype.has : null;
        var $setHas = $WeakSet ? $WeakSet.prototype.has : null;
        if (!exported && !$mapHas) {
            exported = function isWeakMap(x) {
                return false;
            };
        }
        module.exports = exported || function isWeakMap(x) {
            if (!x || typeof x !== "object") {
                return false;
            }
            try {
                $mapHas.call(x, $mapHas);
                if ($setHas) {
                    try {
                        $setHas.call(x, $setHas);
                    } catch (e) {
                        return true;
                    }
                }
                return x instanceof $WeakMap;
            } catch (e) {}
            return false;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var callBound = __webpack_require__(21);
        var $WeakSet = GetIntrinsic("%WeakSet%", true);
        var $setHas = callBound("WeakSet.prototype.has", true);
        if ($setHas) {
            var $mapHas = callBound("WeakMap.prototype.has", true);
            module.exports = function isWeakSet(x) {
                if (!x || typeof x !== "object") {
                    return false;
                }
                try {
                    $setHas(x, $setHas);
                    if ($mapHas) {
                        try {
                            $mapHas(x, $mapHas);
                        } catch (e) {
                            return true;
                        }
                    }
                    return x instanceof $WeakSet;
                } catch (e) {}
                return false;
            };
        } else {
            module.exports = function isWeakSet(x) {
                return false;
            };
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var process = __webpack_require__(56);
        var isArguments = __webpack_require__(18);
        if (__webpack_require__(23)() || __webpack_require__(20)()) {
            var $iterator = Symbol.iterator;
            module.exports = function getIterator(iterable) {
                if (iterable != null && typeof iterable[$iterator] !== "undefined") {
                    return iterable[$iterator]();
                }
                if (isArguments(iterable)) {
                    return Array.prototype[$iterator].call(iterable);
                }
            };
        } else {
            var isArray = __webpack_require__(55);
            var isString = __webpack_require__(43);
            var GetIntrinsic = __webpack_require__(22);
            var $Map = GetIntrinsic("%Map%", true);
            var $Set = GetIntrinsic("%Set%", true);
            var callBound = __webpack_require__(21);
            var $arrayPush = callBound("Array.prototype.push");
            var $charCodeAt = callBound("String.prototype.charCodeAt");
            var $stringSlice = callBound("String.prototype.slice");
            var advanceStringIndex = function advanceStringIndex(S, index) {
                var length = S.length;
                if (index + 1 >= length) {
                    return index + 1;
                }
                var first = $charCodeAt(S, index);
                if (first < 55296 || first > 56319) {
                    return index + 1;
                }
                var second = $charCodeAt(S, index + 1);
                if (second < 56320 || second > 57343) {
                    return index + 1;
                }
                return index + 2;
            };
            var getArrayIterator = function getArrayIterator(arraylike) {
                var i = 0;
                return {
                    next: function next() {
                        var done = i >= arraylike.length;
                        var value;
                        if (!done) {
                            value = arraylike[i];
                            i += 1;
                        }
                        return {
                            done,
                            value
                        };
                    }
                };
            };
            var getNonCollectionIterator = function getNonCollectionIterator(iterable, noPrimordialCollections) {
                if (isArray(iterable) || isArguments(iterable)) {
                    return getArrayIterator(iterable);
                }
                if (isString(iterable)) {
                    var i = 0;
                    return {
                        next: function next() {
                            var nextIndex = advanceStringIndex(iterable, i);
                            var value = $stringSlice(iterable, i, nextIndex);
                            i = nextIndex;
                            return {
                                done: nextIndex > iterable.length,
                                value
                            };
                        }
                    };
                }
                if (noPrimordialCollections && typeof iterable["_es6-shim iterator_"] !== "undefined") {
                    return iterable["_es6-shim iterator_"]();
                }
            };
            if (!$Map && !$Set) {
                module.exports = function getIterator(iterable) {
                    if (iterable != null) {
                        return getNonCollectionIterator(iterable, true);
                    }
                };
            } else {
                var isMap = __webpack_require__(50);
                var isSet = __webpack_require__(51);
                var $mapForEach = callBound("Map.prototype.forEach", true);
                var $setForEach = callBound("Set.prototype.forEach", true);
                if (typeof process === "undefined" || !process.versions || !process.versions.node) {
                    var $mapIterator = callBound("Map.prototype.iterator", true);
                    var $setIterator = callBound("Set.prototype.iterator", true);
                    var getStopIterationIterator = function(iterator) {
                        var done = false;
                        return {
                            next: function next() {
                                try {
                                    return {
                                        done,
                                        value: done ? undefined : iterator.next()
                                    };
                                } catch (e) {
                                    done = true;
                                    return {
                                        done: true,
                                        value: undefined
                                    };
                                }
                            }
                        };
                    };
                }
                var $mapAtAtIterator = callBound("Map.prototype.@@iterator", true) || callBound("Map.prototype._es6-shim iterator_", true);
                var $setAtAtIterator = callBound("Set.prototype.@@iterator", true) || callBound("Set.prototype._es6-shim iterator_", true);
                var getCollectionIterator = function getCollectionIterator(iterable) {
                    if (isMap(iterable)) {
                        if ($mapIterator) {
                            return getStopIterationIterator($mapIterator(iterable));
                        }
                        if ($mapAtAtIterator) {
                            return $mapAtAtIterator(iterable);
                        }
                        if ($mapForEach) {
                            var entries = [];
                            $mapForEach(iterable, (function(v, k) {
                                $arrayPush(entries, [ k, v ]);
                            }));
                            return getArrayIterator(entries);
                        }
                    }
                    if (isSet(iterable)) {
                        if ($setIterator) {
                            return getStopIterationIterator($setIterator(iterable));
                        }
                        if ($setAtAtIterator) {
                            return $setAtAtIterator(iterable);
                        }
                        if ($setForEach) {
                            var values = [];
                            $setForEach(iterable, (function(v) {
                                $arrayPush(values, v);
                            }));
                            return getArrayIterator(values);
                        }
                    }
                };
                module.exports = function getIterator(iterable) {
                    return getCollectionIterator(iterable) || getNonCollectionIterator(iterable);
                };
            }
        }
    }, module => {
        var toString = {}.toString;
        module.exports = Array.isArray || function(arr) {
            return toString.call(arr) == "[object Array]";
        };
    }, module => {
        var process = module.exports = {};
        var cachedSetTimeout;
        var cachedClearTimeout;
        function defaultSetTimout() {
            throw new Error("setTimeout has not been defined");
        }
        function defaultClearTimeout() {
            throw new Error("clearTimeout has not been defined");
        }
        (function() {
            try {
                if (typeof setTimeout === "function") {
                    cachedSetTimeout = setTimeout;
                } else {
                    cachedSetTimeout = defaultSetTimout;
                }
            } catch (e) {
                cachedSetTimeout = defaultSetTimout;
            }
            try {
                if (typeof clearTimeout === "function") {
                    cachedClearTimeout = clearTimeout;
                } else {
                    cachedClearTimeout = defaultClearTimeout;
                }
            } catch (e) {
                cachedClearTimeout = defaultClearTimeout;
            }
        })();
        function runTimeout(fun) {
            if (cachedSetTimeout === setTimeout) {
                return setTimeout(fun, 0);
            }
            if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
                cachedSetTimeout = setTimeout;
                return setTimeout(fun, 0);
            }
            try {
                return cachedSetTimeout(fun, 0);
            } catch (e) {
                try {
                    return cachedSetTimeout.call(null, fun, 0);
                } catch (e) {
                    return cachedSetTimeout.call(this, fun, 0);
                }
            }
        }
        function runClearTimeout(marker) {
            if (cachedClearTimeout === clearTimeout) {
                return clearTimeout(marker);
            }
            if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
                cachedClearTimeout = clearTimeout;
                return clearTimeout(marker);
            }
            try {
                return cachedClearTimeout(marker);
            } catch (e) {
                try {
                    return cachedClearTimeout.call(null, marker);
                } catch (e) {
                    return cachedClearTimeout.call(this, marker);
                }
            }
        }
        var queue = [];
        var draining = false;
        var currentQueue;
        var queueIndex = -1;
        function cleanUpNextTick() {
            if (!draining || !currentQueue) {
                return;
            }
            draining = false;
            if (currentQueue.length) {
                queue = currentQueue.concat(queue);
            } else {
                queueIndex = -1;
            }
            if (queue.length) {
                drainQueue();
            }
        }
        function drainQueue() {
            if (draining) {
                return;
            }
            var timeout = runTimeout(cleanUpNextTick);
            draining = true;
            var len = queue.length;
            while (len) {
                currentQueue = queue;
                queue = [];
                while (++queueIndex < len) {
                    if (currentQueue) {
                        currentQueue[queueIndex].run();
                    }
                }
                queueIndex = -1;
                len = queue.length;
            }
            currentQueue = null;
            draining = false;
            runClearTimeout(timeout);
        }
        process.nextTick = function(fun) {
            var args = new Array(arguments.length - 1);
            if (arguments.length > 1) {
                for (var i = 1; i < arguments.length; i++) {
                    args[i - 1] = arguments[i];
                }
            }
            queue.push(new Item(fun, args));
            if (queue.length === 1 && !draining) {
                runTimeout(drainQueue);
            }
        };
        function Item(fun, array) {
            this.fun = fun;
            this.array = array;
        }
        Item.prototype.run = function() {
            this.fun.apply(null, this.array);
        };
        process.title = "browser";
        process.browser = true;
        process.env = {};
        process.argv = [];
        process.version = "";
        process.versions = {};
        function noop() {}
        process.on = noop;
        process.addListener = noop;
        process.once = noop;
        process.off = noop;
        process.removeListener = noop;
        process.removeAllListeners = noop;
        process.emit = noop;
        process.prependListener = noop;
        process.prependOnceListener = noop;
        process.listeners = function(name) {
            return [];
        };
        process.binding = function(name) {
            throw new Error("process.binding is not supported");
        };
        process.cwd = function() {
            return "/";
        };
        process.chdir = function(dir) {
            throw new Error("process.chdir is not supported");
        };
        process.umask = function() {
            return 0;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var callBound = __webpack_require__(21);
        var inspect = __webpack_require__(58);
        var $TypeError = GetIntrinsic("%TypeError%");
        var $WeakMap = GetIntrinsic("%WeakMap%", true);
        var $Map = GetIntrinsic("%Map%", true);
        var $weakMapGet = callBound("WeakMap.prototype.get", true);
        var $weakMapSet = callBound("WeakMap.prototype.set", true);
        var $weakMapHas = callBound("WeakMap.prototype.has", true);
        var $mapGet = callBound("Map.prototype.get", true);
        var $mapSet = callBound("Map.prototype.set", true);
        var $mapHas = callBound("Map.prototype.has", true);
        var listGetNode = function(list, key) {
            for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
                if (curr.key === key) {
                    prev.next = curr.next;
                    curr.next = list.next;
                    list.next = curr;
                    return curr;
                }
            }
        };
        var listGet = function(objects, key) {
            var node = listGetNode(objects, key);
            return node && node.value;
        };
        var listSet = function(objects, key, value) {
            var node = listGetNode(objects, key);
            if (node) {
                node.value = value;
            } else {
                objects.next = {
                    key,
                    next: objects.next,
                    value
                };
            }
        };
        var listHas = function(objects, key) {
            return !!listGetNode(objects, key);
        };
        module.exports = function getSideChannel() {
            var $wm;
            var $m;
            var $o;
            var channel = {
                assert: function(key) {
                    if (!channel.has(key)) {
                        throw new $TypeError("Side channel does not contain " + inspect(key));
                    }
                },
                get: function(key) {
                    if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
                        if ($wm) {
                            return $weakMapGet($wm, key);
                        }
                    } else if ($Map) {
                        if ($m) {
                            return $mapGet($m, key);
                        }
                    } else {
                        if ($o) {
                            return listGet($o, key);
                        }
                    }
                },
                has: function(key) {
                    if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
                        if ($wm) {
                            return $weakMapHas($wm, key);
                        }
                    } else if ($Map) {
                        if ($m) {
                            return $mapHas($m, key);
                        }
                    } else {
                        if ($o) {
                            return listHas($o, key);
                        }
                    }
                    return false;
                },
                set: function(key, value) {
                    if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
                        if (!$wm) {
                            $wm = new $WeakMap;
                        }
                        $weakMapSet($wm, key, value);
                    } else if ($Map) {
                        if (!$m) {
                            $m = new $Map;
                        }
                        $mapSet($m, key, value);
                    } else {
                        if (!$o) {
                            $o = {
                                key: {},
                                next: null
                            };
                        }
                        listSet($o, key, value);
                    }
                }
            };
            return channel;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        var hasMap = typeof Map === "function" && Map.prototype;
        var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
        var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
        var mapForEach = hasMap && Map.prototype.forEach;
        var hasSet = typeof Set === "function" && Set.prototype;
        var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
        var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
        var setForEach = hasSet && Set.prototype.forEach;
        var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
        var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
        var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
        var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
        var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
        var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
        var booleanValueOf = Boolean.prototype.valueOf;
        var objectToString = Object.prototype.toString;
        var functionToString = Function.prototype.toString;
        var $match = String.prototype.match;
        var $slice = String.prototype.slice;
        var $replace = String.prototype.replace;
        var $toUpperCase = String.prototype.toUpperCase;
        var $toLowerCase = String.prototype.toLowerCase;
        var $test = RegExp.prototype.test;
        var $concat = Array.prototype.concat;
        var $join = Array.prototype.join;
        var $arrSlice = Array.prototype.slice;
        var $floor = Math.floor;
        var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
        var gOPS = Object.getOwnPropertySymbols;
        var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
        var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
        var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
        var isEnumerable = Object.prototype.propertyIsEnumerable;
        var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
            return O.__proto__;
        } : null);
        function addNumericSeparator(num, str) {
            if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {
                return str;
            }
            var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
            if (typeof num === "number") {
                var int = num < 0 ? -$floor(-num) : $floor(num);
                if (int !== num) {
                    var intStr = String(int);
                    var dec = $slice.call(str, intStr.length + 1);
                    return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
                }
            }
            return $replace.call(str, sepRegex, "$&_");
        }
        var utilInspect = __webpack_require__(59);
        var inspectCustom = utilInspect.custom;
        var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
        module.exports = function inspect_(obj, options, depth, seen) {
            var opts = options || {};
            if (has(opts, "quoteStyle") && (opts.quoteStyle !== "single" && opts.quoteStyle !== "double")) {
                throw new TypeError('option "quoteStyle" must be "single" or "double"');
            }
            if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
                throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
            }
            var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
            if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
                throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
            }
            if (has(opts, "indent") && opts.indent !== null && opts.indent !== "\t" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
                throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
            }
            if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
                throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
            }
            var numericSeparator = opts.numericSeparator;
            if (typeof obj === "undefined") {
                return "undefined";
            }
            if (obj === null) {
                return "null";
            }
            if (typeof obj === "boolean") {
                return obj ? "true" : "false";
            }
            if (typeof obj === "string") {
                return inspectString(obj, opts);
            }
            if (typeof obj === "number") {
                if (obj === 0) {
                    return Infinity / obj > 0 ? "0" : "-0";
                }
                var str = String(obj);
                return numericSeparator ? addNumericSeparator(obj, str) : str;
            }
            if (typeof obj === "bigint") {
                var bigIntStr = String(obj) + "n";
                return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
            }
            var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
            if (typeof depth === "undefined") {
                depth = 0;
            }
            if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
                return isArray(obj) ? "[Array]" : "[Object]";
            }
            var indent = getIndent(opts, depth);
            if (typeof seen === "undefined") {
                seen = [];
            } else if (indexOf(seen, obj) >= 0) {
                return "[Circular]";
            }
            function inspect(value, from, noIndent) {
                if (from) {
                    seen = $arrSlice.call(seen);
                    seen.push(from);
                }
                if (noIndent) {
                    var newOpts = {
                        depth: opts.depth
                    };
                    if (has(opts, "quoteStyle")) {
                        newOpts.quoteStyle = opts.quoteStyle;
                    }
                    return inspect_(value, newOpts, depth + 1, seen);
                }
                return inspect_(value, opts, depth + 1, seen);
            }
            if (typeof obj === "function" && !isRegExp(obj)) {
                var name = nameOf(obj);
                var keys = arrObjKeys(obj, inspect);
                return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
            }
            if (isSymbol(obj)) {
                var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
                return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
            }
            if (isElement(obj)) {
                var s = "<" + $toLowerCase.call(String(obj.nodeName));
                var attrs = obj.attributes || [];
                for (var i = 0; i < attrs.length; i++) {
                    s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
                }
                s += ">";
                if (obj.childNodes && obj.childNodes.length) {
                    s += "...";
                }
                s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
                return s;
            }
            if (isArray(obj)) {
                if (obj.length === 0) {
                    return "[]";
                }
                var xs = arrObjKeys(obj, inspect);
                if (indent && !singleLineValues(xs)) {
                    return "[" + indentedJoin(xs, indent) + "]";
                }
                return "[ " + $join.call(xs, ", ") + " ]";
            }
            if (isError(obj)) {
                var parts = arrObjKeys(obj, inspect);
                if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
                    return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }";
                }
                if (parts.length === 0) {
                    return "[" + String(obj) + "]";
                }
                return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
            }
            if (typeof obj === "object" && customInspect) {
                if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {
                    return utilInspect(obj, {
                        depth: maxDepth - depth
                    });
                } else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
                    return obj.inspect();
                }
            }
            if (isMap(obj)) {
                var mapParts = [];
                mapForEach.call(obj, (function(value, key) {
                    mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj));
                }));
                return collectionOf("Map", mapSize.call(obj), mapParts, indent);
            }
            if (isSet(obj)) {
                var setParts = [];
                setForEach.call(obj, (function(value) {
                    setParts.push(inspect(value, obj));
                }));
                return collectionOf("Set", setSize.call(obj), setParts, indent);
            }
            if (isWeakMap(obj)) {
                return weakCollectionOf("WeakMap");
            }
            if (isWeakSet(obj)) {
                return weakCollectionOf("WeakSet");
            }
            if (isWeakRef(obj)) {
                return weakCollectionOf("WeakRef");
            }
            if (isNumber(obj)) {
                return markBoxed(inspect(Number(obj)));
            }
            if (isBigInt(obj)) {
                return markBoxed(inspect(bigIntValueOf.call(obj)));
            }
            if (isBoolean(obj)) {
                return markBoxed(booleanValueOf.call(obj));
            }
            if (isString(obj)) {
                return markBoxed(inspect(String(obj)));
            }
            if (!isDate(obj) && !isRegExp(obj)) {
                var ys = arrObjKeys(obj, inspect);
                var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
                var protoTag = obj instanceof Object ? "" : "null prototype";
                var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
                var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
                var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
                if (ys.length === 0) {
                    return tag + "{}";
                }
                if (indent) {
                    return tag + "{" + indentedJoin(ys, indent) + "}";
                }
                return tag + "{ " + $join.call(ys, ", ") + " }";
            }
            return String(obj);
        };
        function wrapQuotes(s, defaultStyle, opts) {
            var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'";
            return quoteChar + s + quoteChar;
        }
        function quote(s) {
            return $replace.call(String(s), /"/g, "&quot;");
        }
        function isArray(obj) {
            return toStr(obj) === "[object Array]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isDate(obj) {
            return toStr(obj) === "[object Date]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isRegExp(obj) {
            return toStr(obj) === "[object RegExp]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isError(obj) {
            return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isString(obj) {
            return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isNumber(obj) {
            return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isBoolean(obj) {
            return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
        }
        function isSymbol(obj) {
            if (hasShammedSymbols) {
                return obj && typeof obj === "object" && obj instanceof Symbol;
            }
            if (typeof obj === "symbol") {
                return true;
            }
            if (!obj || typeof obj !== "object" || !symToString) {
                return false;
            }
            try {
                symToString.call(obj);
                return true;
            } catch (e) {}
            return false;
        }
        function isBigInt(obj) {
            if (!obj || typeof obj !== "object" || !bigIntValueOf) {
                return false;
            }
            try {
                bigIntValueOf.call(obj);
                return true;
            } catch (e) {}
            return false;
        }
        var hasOwn = Object.prototype.hasOwnProperty || function(key) {
            return key in this;
        };
        function has(obj, key) {
            return hasOwn.call(obj, key);
        }
        function toStr(obj) {
            return objectToString.call(obj);
        }
        function nameOf(f) {
            if (f.name) {
                return f.name;
            }
            var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
            if (m) {
                return m[1];
            }
            return null;
        }
        function indexOf(xs, x) {
            if (xs.indexOf) {
                return xs.indexOf(x);
            }
            for (var i = 0, l = xs.length; i < l; i++) {
                if (xs[i] === x) {
                    return i;
                }
            }
            return -1;
        }
        function isMap(x) {
            if (!mapSize || !x || typeof x !== "object") {
                return false;
            }
            try {
                mapSize.call(x);
                try {
                    setSize.call(x);
                } catch (s) {
                    return true;
                }
                return x instanceof Map;
            } catch (e) {}
            return false;
        }
        function isWeakMap(x) {
            if (!weakMapHas || !x || typeof x !== "object") {
                return false;
            }
            try {
                weakMapHas.call(x, weakMapHas);
                try {
                    weakSetHas.call(x, weakSetHas);
                } catch (s) {
                    return true;
                }
                return x instanceof WeakMap;
            } catch (e) {}
            return false;
        }
        function isWeakRef(x) {
            if (!weakRefDeref || !x || typeof x !== "object") {
                return false;
            }
            try {
                weakRefDeref.call(x);
                return true;
            } catch (e) {}
            return false;
        }
        function isSet(x) {
            if (!setSize || !x || typeof x !== "object") {
                return false;
            }
            try {
                setSize.call(x);
                try {
                    mapSize.call(x);
                } catch (m) {
                    return true;
                }
                return x instanceof Set;
            } catch (e) {}
            return false;
        }
        function isWeakSet(x) {
            if (!weakSetHas || !x || typeof x !== "object") {
                return false;
            }
            try {
                weakSetHas.call(x, weakSetHas);
                try {
                    weakMapHas.call(x, weakMapHas);
                } catch (s) {
                    return true;
                }
                return x instanceof WeakSet;
            } catch (e) {}
            return false;
        }
        function isElement(x) {
            if (!x || typeof x !== "object") {
                return false;
            }
            if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) {
                return true;
            }
            return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
        }
        function inspectString(str, opts) {
            if (str.length > opts.maxStringLength) {
                var remaining = str.length - opts.maxStringLength;
                var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
                return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
            }
            var s = $replace.call($replace.call(str, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, lowbyte);
            return wrapQuotes(s, "single", opts);
        }
        function lowbyte(c) {
            var n = c.charCodeAt(0);
            var x = {
                8: "b",
                9: "t",
                10: "n",
                12: "f",
                13: "r"
            }[n];
            if (x) {
                return "\\" + x;
            }
            return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
        }
        function markBoxed(str) {
            return "Object(" + str + ")";
        }
        function weakCollectionOf(type) {
            return type + " { ? }";
        }
        function collectionOf(type, size, entries, indent) {
            var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
            return type + " (" + size + ") {" + joinedEntries + "}";
        }
        function singleLineValues(xs) {
            for (var i = 0; i < xs.length; i++) {
                if (indexOf(xs[i], "\n") >= 0) {
                    return false;
                }
            }
            return true;
        }
        function getIndent(opts, depth) {
            var baseIndent;
            if (opts.indent === "\t") {
                baseIndent = "\t";
            } else if (typeof opts.indent === "number" && opts.indent > 0) {
                baseIndent = $join.call(Array(opts.indent + 1), " ");
            } else {
                return null;
            }
            return {
                base: baseIndent,
                prev: $join.call(Array(depth + 1), baseIndent)
            };
        }
        function indentedJoin(xs, indent) {
            if (xs.length === 0) {
                return "";
            }
            var lineJoiner = "\n" + indent.prev + indent.base;
            return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
        }
        function arrObjKeys(obj, inspect) {
            var isArr = isArray(obj);
            var xs = [];
            if (isArr) {
                xs.length = obj.length;
                for (var i = 0; i < obj.length; i++) {
                    xs[i] = has(obj, i) ? inspect(obj[i], obj) : "";
                }
            }
            var syms = typeof gOPS === "function" ? gOPS(obj) : [];
            var symMap;
            if (hasShammedSymbols) {
                symMap = {};
                for (var k = 0; k < syms.length; k++) {
                    symMap["$" + syms[k]] = syms[k];
                }
            }
            for (var key in obj) {
                if (!has(obj, key)) {
                    continue;
                }
                if (isArr && String(Number(key)) === key && key < obj.length) {
                    continue;
                }
                if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
                    continue;
                } else if ($test.call(/[^\w$]/, key)) {
                    xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj));
                } else {
                    xs.push(key + ": " + inspect(obj[key], obj));
                }
            }
            if (typeof gOPS === "function") {
                for (var j = 0; j < syms.length; j++) {
                    if (isEnumerable.call(obj, syms[j])) {
                        xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
                    }
                }
            }
            return xs;
        }
    }, () => {}, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var forEach = __webpack_require__(61);
        var availableTypedArrays = __webpack_require__(63);
        var callBound = __webpack_require__(21);
        var $toString = callBound("Object.prototype.toString");
        var hasToStringTag = __webpack_require__(19)();
        var g = typeof globalThis === "undefined" ? __webpack_require__.g : globalThis;
        var typedArrays = availableTypedArrays();
        var $slice = callBound("String.prototype.slice");
        var toStrTags = {};
        var gOPD = __webpack_require__(64);
        var getPrototypeOf = Object.getPrototypeOf;
        if (hasToStringTag && gOPD && getPrototypeOf) {
            forEach(typedArrays, (function(typedArray) {
                if (typeof g[typedArray] === "function") {
                    var arr = new g[typedArray];
                    if (Symbol.toStringTag in arr) {
                        var proto = getPrototypeOf(arr);
                        var descriptor = gOPD(proto, Symbol.toStringTag);
                        if (!descriptor) {
                            var superProto = getPrototypeOf(proto);
                            descriptor = gOPD(superProto, Symbol.toStringTag);
                        }
                        toStrTags[typedArray] = descriptor.get;
                    }
                }
            }));
        }
        var tryTypedArrays = function tryAllTypedArrays(value) {
            var foundName = false;
            forEach(toStrTags, (function(getter, typedArray) {
                if (!foundName) {
                    try {
                        var name = getter.call(value);
                        if (name === typedArray) {
                            foundName = name;
                        }
                    } catch (e) {}
                }
            }));
            return foundName;
        };
        var isTypedArray = __webpack_require__(65);
        module.exports = function whichTypedArray(value) {
            if (!isTypedArray(value)) {
                return false;
            }
            if (!hasToStringTag || !(Symbol.toStringTag in value)) {
                return $slice($toString(value), 8, -1);
            }
            return tryTypedArrays(value);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var isCallable = __webpack_require__(62);
        var toStr = Object.prototype.toString;
        var hasOwnProperty = Object.prototype.hasOwnProperty;
        var forEachArray = function forEachArray(array, iterator, receiver) {
            for (var i = 0, len = array.length; i < len; i++) {
                if (hasOwnProperty.call(array, i)) {
                    if (receiver == null) {
                        iterator(array[i], i, array);
                    } else {
                        iterator.call(receiver, array[i], i, array);
                    }
                }
            }
        };
        var forEachString = function forEachString(string, iterator, receiver) {
            for (var i = 0, len = string.length; i < len; i++) {
                if (receiver == null) {
                    iterator(string.charAt(i), i, string);
                } else {
                    iterator.call(receiver, string.charAt(i), i, string);
                }
            }
        };
        var forEachObject = function forEachObject(object, iterator, receiver) {
            for (var k in object) {
                if (hasOwnProperty.call(object, k)) {
                    if (receiver == null) {
                        iterator(object[k], k, object);
                    } else {
                        iterator.call(receiver, object[k], k, object);
                    }
                }
            }
        };
        var forEach = function forEach(list, iterator, thisArg) {
            if (!isCallable(iterator)) {
                throw new TypeError("iterator must be a function");
            }
            var receiver;
            if (arguments.length >= 3) {
                receiver = thisArg;
            }
            if (toStr.call(list) === "[object Array]") {
                forEachArray(list, iterator, receiver);
            } else if (typeof list === "string") {
                forEachString(list, iterator, receiver);
            } else {
                forEachObject(list, iterator, receiver);
            }
        };
        module.exports = forEach;
    }, module => {
        "use strict";
        var fnToStr = Function.prototype.toString;
        var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
        var badArrayLike;
        var isCallableMarker;
        if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
            try {
                badArrayLike = Object.defineProperty({}, "length", {
                    get: function() {
                        throw isCallableMarker;
                    }
                });
                isCallableMarker = {};
                reflectApply((function() {
                    throw 42;
                }), null, badArrayLike);
            } catch (_) {
                if (_ !== isCallableMarker) {
                    reflectApply = null;
                }
            }
        } else {
            reflectApply = null;
        }
        var constructorRegex = /^\s*class\b/;
        var isES6ClassFn = function isES6ClassFunction(value) {
            try {
                var fnStr = fnToStr.call(value);
                return constructorRegex.test(fnStr);
            } catch (e) {
                return false;
            }
        };
        var tryFunctionObject = function tryFunctionToStr(value) {
            try {
                if (isES6ClassFn(value)) {
                    return false;
                }
                fnToStr.call(value);
                return true;
            } catch (e) {
                return false;
            }
        };
        var toStr = Object.prototype.toString;
        var fnClass = "[object Function]";
        var genClass = "[object GeneratorFunction]";
        var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
        var documentDotAll = typeof document === "object" && typeof document.all === "undefined" && document.all !== undefined ? document.all : {};
        module.exports = reflectApply ? function isCallable(value) {
            if (value === documentDotAll) {
                return true;
            }
            if (!value) {
                return false;
            }
            if (typeof value !== "function" && typeof value !== "object") {
                return false;
            }
            if (typeof value === "function" && !value.prototype) {
                return true;
            }
            try {
                reflectApply(value, null, badArrayLike);
            } catch (e) {
                if (e !== isCallableMarker) {
                    return false;
                }
            }
            return !isES6ClassFn(value);
        } : function isCallable(value) {
            if (value === documentDotAll) {
                return true;
            }
            if (!value) {
                return false;
            }
            if (typeof value !== "function" && typeof value !== "object") {
                return false;
            }
            if (typeof value === "function" && !value.prototype) {
                return true;
            }
            if (hasToStringTag) {
                return tryFunctionObject(value);
            }
            if (isES6ClassFn(value)) {
                return false;
            }
            var strClass = toStr.call(value);
            return strClass === fnClass || strClass === genClass;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var possibleNames = [ "BigInt64Array", "BigUint64Array", "Float32Array", "Float64Array", "Int16Array", "Int32Array", "Int8Array", "Uint16Array", "Uint32Array", "Uint8Array", "Uint8ClampedArray" ];
        var g = typeof globalThis === "undefined" ? __webpack_require__.g : globalThis;
        module.exports = function availableTypedArrays() {
            var out = [];
            for (var i = 0; i < possibleNames.length; i++) {
                if (typeof g[possibleNames[i]] === "function") {
                    out[out.length] = possibleNames[i];
                }
            }
            return out;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
        if ($gOPD) {
            try {
                $gOPD([], "length");
            } catch (e) {
                $gOPD = null;
            }
        }
        module.exports = $gOPD;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var forEach = __webpack_require__(61);
        var availableTypedArrays = __webpack_require__(63);
        var callBound = __webpack_require__(21);
        var $toString = callBound("Object.prototype.toString");
        var hasToStringTag = __webpack_require__(19)();
        var g = typeof globalThis === "undefined" ? __webpack_require__.g : globalThis;
        var typedArrays = availableTypedArrays();
        var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
            for (var i = 0; i < array.length; i += 1) {
                if (array[i] === value) {
                    return i;
                }
            }
            return -1;
        };
        var $slice = callBound("String.prototype.slice");
        var toStrTags = {};
        var gOPD = __webpack_require__(64);
        var getPrototypeOf = Object.getPrototypeOf;
        if (hasToStringTag && gOPD && getPrototypeOf) {
            forEach(typedArrays, (function(typedArray) {
                var arr = new g[typedArray];
                if (Symbol.toStringTag in arr) {
                    var proto = getPrototypeOf(arr);
                    var descriptor = gOPD(proto, Symbol.toStringTag);
                    if (!descriptor) {
                        var superProto = getPrototypeOf(proto);
                        descriptor = gOPD(superProto, Symbol.toStringTag);
                    }
                    toStrTags[typedArray] = descriptor.get;
                }
            }));
        }
        var tryTypedArrays = function tryAllTypedArrays(value) {
            var anyTrue = false;
            forEach(toStrTags, (function(getter, typedArray) {
                if (!anyTrue) {
                    try {
                        anyTrue = getter.call(value) === typedArray;
                    } catch (e) {}
                }
            }));
            return anyTrue;
        };
        module.exports = function isTypedArray(value) {
            if (!value || typeof value !== "object") {
                return false;
            }
            if (!hasToStringTag || !(Symbol.toStringTag in value)) {
                var tag = $slice($toString(value), 8, -1);
                return $indexOf(typedArrays, tag) > -1;
            }
            if (!gOPD) {
                return false;
            }
            return tryTypedArrays(value);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var defineProperties = __webpack_require__(29);
        var callBind = __webpack_require__(27);
        var implementation = __webpack_require__(67);
        var getPolyfill = __webpack_require__(68);
        var shim = __webpack_require__(69);
        var polyfill = callBind.apply(getPolyfill());
        var bound = function assign(target, source1) {
            return polyfill(Object, arguments);
        };
        defineProperties(bound, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = bound;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var keys = __webpack_require__(15);
        var canBeObject = function(obj) {
            return typeof obj !== "undefined" && obj !== null;
        };
        var hasSymbols = __webpack_require__(20)();
        var callBound = __webpack_require__(21);
        var toObject = Object;
        var $push = callBound("Array.prototype.push");
        var $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable");
        var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;
        module.exports = function assign(target, source1) {
            if (!canBeObject(target)) {
                throw new TypeError("target must be an object");
            }
            var objTarget = toObject(target);
            var s, source, i, props, syms, value, key;
            for (s = 1; s < arguments.length; ++s) {
                source = toObject(arguments[s]);
                props = keys(source);
                var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols);
                if (getSymbols) {
                    syms = getSymbols(source);
                    for (i = 0; i < syms.length; ++i) {
                        key = syms[i];
                        if ($propIsEnumerable(source, key)) {
                            $push(props, key);
                        }
                    }
                }
                for (i = 0; i < props.length; ++i) {
                    key = props[i];
                    value = source[key];
                    if ($propIsEnumerable(source, key)) {
                        objTarget[key] = value;
                    }
                }
            }
            return objTarget;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(67);
        var lacksProperEnumerationOrder = function() {
            if (!Object.assign) {
                return false;
            }
            var str = "abcdefghijklmnopqrst";
            var letters = str.split("");
            var map = {};
            for (var i = 0; i < letters.length; ++i) {
                map[letters[i]] = letters[i];
            }
            var obj = Object.assign({}, map);
            var actual = "";
            for (var k in obj) {
                actual += k;
            }
            return str !== actual;
        };
        var assignHasPendingExceptions = function() {
            if (!Object.assign || !Object.preventExtensions) {
                return false;
            }
            var thrower = Object.preventExtensions({
                1: 2
            });
            try {
                Object.assign(thrower, "xy");
            } catch (e) {
                return thrower[1] === "y";
            }
            return false;
        };
        module.exports = function getPolyfill() {
            if (!Object.assign) {
                return implementation;
            }
            if (lacksProperEnumerationOrder()) {
                return implementation;
            }
            if (assignHasPendingExceptions()) {
                return implementation;
            }
            return Object.assign;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var getPolyfill = __webpack_require__(68);
        module.exports = function shimAssign() {
            var polyfill = getPolyfill();
            define(Object, {
                assign: polyfill
            }, {
                assign: function() {
                    return Object.assign !== polyfill;
                }
            });
            return polyfill;
        };
    }, module => {
        "use strict";
        module.exports = window._;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            customizeValues: () => customizeValues,
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _generic_control__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var customizeValues = function customizeValues() {
            return Object.keys(wp.customize._value).reduce((function(finalValue, currentValue) {
                return _objectSpread(_objectSpread({}, finalValue), {}, _defineProperty({}, currentValue, wp.customize._value[currentValue]()));
            }), {});
        };
        var NestedControls = function(_Component) {
            _inherits(NestedControls, _Component);
            var _super = _createSuper(NestedControls);
            function NestedControls() {
                _classCallCheck(this, NestedControls);
                return _super.apply(this, arguments);
            }
            _createClass(NestedControls, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, value = _this$props.value, controls = _this$props.controls, _onChange = _this$props.onChange;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Fragment, {
                        children: controls.map((function(control) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(_generic_control__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                id: control.id,
                                settings: value,
                                options: Object.assign({}, control, control.options || {}),
                                onChange: function onChange(v, id) {
                                    _onChange(v, id || control.id, id === control.id);
                                    LottaEvents.trigger("lotta-setting-change", control.id, v);
                                }
                            }, control.id);
                        }))
                    });
                }
            } ]);
            return NestedControls;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = NestedControls;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => GenericControl,
            getControlComponent: () => getControlComponent
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
        var _controls__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(73);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var getControlComponent = function getControlComponent(control) {
            return _controls__WEBPACK_IMPORTED_MODULE_2__["default"][control.type] || null;
        };
        var GenericControl = function(_Component) {
            _inherits(GenericControl, _Component);
            var _super = _createSuper(GenericControl);
            function GenericControl() {
                _classCallCheck(this, GenericControl);
                return _super.apply(this, arguments);
            }
            _createClass(GenericControl, [ {
                key: "render",
                value: function render() {
                    var _this = this;
                    var _this$props = this.props, options = _this$props.options, settings = _this$props.settings, id = _this$props.id, _onChange = _this$props.onChange;
                    var Component = getControlComponent(options);
                    if (!Component) {
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                            children: [ "Unimplemented option: ", options.type ]
                        });
                    }
                    var value = undefined;
                    var controlSettings = settings;
                    if (typeof settings === "function") {
                        controlSettings = settings();
                    }
                    if (controlSettings === _index__WEBPACK_IMPORTED_MODULE_1__.CZ_VALUES || controlSettings === undefined) {
                        value = wp.customize(id) ? wp.customize(id).get() : undefined;
                    } else {
                        value = (controlSettings || {})[id];
                    }
                    return (0, _index__WEBPACK_IMPORTED_MODULE_1__.buildControl)({
                        id,
                        options,
                        value,
                        settings,
                        Component,
                        onChange: function onChange(v, settingId) {
                            _onChange(v, settingId || id);
                            if (value === _index__WEBPACK_IMPORTED_MODULE_1__.CONTAINER_CONTROL || v === value) {
                                return;
                            }
                            _this.forceUpdate();
                        }
                    });
                }
            } ]);
            return GenericControl;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _text__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74);
        var _text_area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(76);
        var _number__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(77);
        var _slider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(174);
        var _toggle__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(176);
        var _section__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(177);
        var _color_picker__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(189);
        var _border__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(266);
        var _color_palettes__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(267);
        var _spacing__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(268);
        var _select__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(270);
        var _radio__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(271);
        var _image_radio__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(273);
        var _separator__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(274);
        var _tabs__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(275);
        var _collapse__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(276);
        var _layers__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(278);
        var _placeholder__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(292);
        var _editor__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(293);
        var _info__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(298);
        var _call_to_action__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(299);
        var _tags__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(300);
        var _query_tags__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(302);
        var _image_uploader__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(304);
        var _background__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(305);
        var _box_shadow__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(307);
        var _typography__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(308);
        var _condition__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(313);
        var _page_builder__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(314);
        var _builder__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(323);
        var _repeater__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(328);
        var _icons__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(329);
        var _multi_select__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(330);
        var _filters__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(331);
        var _file_uploader__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(332);
        var controls = {
            "lotta-text": _text__WEBPACK_IMPORTED_MODULE_0__["default"],
            "lotta-text-area": _text_area__WEBPACK_IMPORTED_MODULE_1__["default"],
            "lotta-number": _number__WEBPACK_IMPORTED_MODULE_2__["default"],
            "lotta-slider": _slider__WEBPACK_IMPORTED_MODULE_3__["default"],
            "lotta-toggle": _toggle__WEBPACK_IMPORTED_MODULE_4__["default"],
            "lotta-border": _border__WEBPACK_IMPORTED_MODULE_7__["default"],
            "lotta-color-picker": _color_picker__WEBPACK_IMPORTED_MODULE_6__["default"],
            "lotta-color-palettes": _color_palettes__WEBPACK_IMPORTED_MODULE_8__["default"],
            "lotta-spacing": _spacing__WEBPACK_IMPORTED_MODULE_9__["default"],
            "lotta-select": _select__WEBPACK_IMPORTED_MODULE_10__["default"],
            "lotta-radio": _radio__WEBPACK_IMPORTED_MODULE_11__["default"],
            "lotta-image-radio": _image_radio__WEBPACK_IMPORTED_MODULE_12__["default"],
            "lotta-separator": _separator__WEBPACK_IMPORTED_MODULE_13__["default"],
            "lotta-section": _section__WEBPACK_IMPORTED_MODULE_5__["default"],
            "lotta-tabs": _tabs__WEBPACK_IMPORTED_MODULE_14__["default"],
            "lotta-collapse": _collapse__WEBPACK_IMPORTED_MODULE_15__["default"],
            "lotta-layers": _layers__WEBPACK_IMPORTED_MODULE_16__["default"],
            "lotta-placeholder": _placeholder__WEBPACK_IMPORTED_MODULE_17__["default"],
            "lotta-editor": _editor__WEBPACK_IMPORTED_MODULE_18__["default"],
            "lotta-info": _info__WEBPACK_IMPORTED_MODULE_19__["default"],
            "lotta-cta": _call_to_action__WEBPACK_IMPORTED_MODULE_20__["default"],
            "lotta-tags": _tags__WEBPACK_IMPORTED_MODULE_21__["default"],
            "lotta-query-tags": _query_tags__WEBPACK_IMPORTED_MODULE_22__["default"],
            "lotta-image-uploader": _image_uploader__WEBPACK_IMPORTED_MODULE_23__["default"],
            "lotta-background": _background__WEBPACK_IMPORTED_MODULE_24__["default"],
            "lotta-box-shadow": _box_shadow__WEBPACK_IMPORTED_MODULE_25__["default"],
            "lotta-typography": _typography__WEBPACK_IMPORTED_MODULE_26__["default"],
            "lotta-condition": _condition__WEBPACK_IMPORTED_MODULE_27__["default"],
            "lotta-page-builder": _page_builder__WEBPACK_IMPORTED_MODULE_28__["default"],
            "lotta-builder": _builder__WEBPACK_IMPORTED_MODULE_29__["default"],
            "lotta-repeater": _repeater__WEBPACK_IMPORTED_MODULE_30__["default"],
            "lotta-icons": _icons__WEBPACK_IMPORTED_MODULE_31__["default"],
            "lotta-multi-select": _multi_select__WEBPACK_IMPORTED_MODULE_32__["default"],
            "lotta-css-filters": _filters__WEBPACK_IMPORTED_MODULE_33__["default"],
            "lotta-file-uploader": _file_uploader__WEBPACK_IMPORTED_MODULE_34__["default"]
        };
        const __WEBPACK_DEFAULT_EXPORT__ = controls;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _throttler__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(75);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Text = function(_Component) {
            _inherits(Text, _Component);
            var _super = _createSuper(Text);
            function Text() {
                var _this;
                _classCallCheck(this, Text);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    value: _this.props.value
                });
                return _this;
            }
            _createClass(Text, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, options = _this$props.options, _onChange = _this$props.onChange;
                    var value = this.state.value;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("input", _objectSpread(_objectSpread({
                        type: "text",
                        defaultValue: value
                    }, _objectSpread(_objectSpread({}, options.field_attr ? options.field_attr : {}), options.attr && options.attr.placeholder ? {
                        placeholder: options.attr.placeholder
                    } : {})), {}, {
                        onChange: function onChange(_ref) {
                            var value = _ref.target.value;
                            if (!_this2.throttler) {
                                _this2.throttler = new _throttler__WEBPACK_IMPORTED_MODULE_0__["default"](300, (function(changes) {
                                    var _changes = _slicedToArray(changes[changes.length - 1], 1), newValue = _changes[0];
                                    _onChange(newValue);
                                }));
                            }
                            _this2.setState({
                                value
                            });
                            _this2.throttler.buffer(value);
                        }
                    }, options.select_on_focus ? {
                        onFocus: function onFocus(_ref2) {
                            var target = _ref2.target;
                            return target.select();
                        }
                    } : {}));
                }
            } ]);
            return Text;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Text;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Throttler = function() {
            function Throttler(timeout, callback) {
                _classCallCheck(this, Throttler);
                _defineProperty(this, "bufferedData", []);
                _defineProperty(this, "timer", null);
                _defineProperty(this, "callback", (function() {
                    return null;
                }));
                this.timeout = timeout;
                this.callback = callback;
            }
            _createClass(Throttler, [ {
                key: "buffer",
                value: function buffer() {
                    var _this = this;
                    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                        args[_key] = arguments[_key];
                    }
                    this.bufferedData.push(args);
                    if (!this.timer) {
                        this.timer = setTimeout((function() {
                            var data = _this.bufferedData;
                            _this.bufferedData = [];
                            _this.timer = null;
                            if ("function" === typeof _this.callback) {
                                _this.callback(data);
                            }
                        }), this.timeout);
                    }
                }
            } ]);
            return Throttler;
        }();
        const __WEBPACK_DEFAULT_EXPORT__ = Throttler;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _throttler__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(75);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var TextArea = function(_Component) {
            _inherits(TextArea, _Component);
            var _super = _createSuper(TextArea);
            function TextArea() {
                var _this;
                _classCallCheck(this, TextArea);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    value: _this.props.value
                });
                return _this;
            }
            _createClass(TextArea, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, options = _this$props.options, _onChange = _this$props.onChange;
                    var value = this.state.value;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("textarea", _objectSpread(_objectSpread({
                        defaultValue: value
                    }, _objectSpread(_objectSpread({}, options.field_attr ? options.field_attr : {}), options.attr && options.attr.placeholder ? {
                        placeholder: options.attr.placeholder
                    } : {})), {}, {
                        onChange: function onChange(_ref) {
                            var value = _ref.target.value;
                            if (!_this2.throttler) {
                                _this2.throttler = new _throttler__WEBPACK_IMPORTED_MODULE_1__["default"](300, (function(changes) {
                                    var _changes = _slicedToArray(changes[changes.length - 1], 1), newValue = _changes[0];
                                    _onChange(newValue);
                                }));
                            }
                            _this2.setState({
                                value
                            });
                            _this2.throttler.buffer(value);
                        }
                    }, options.select_on_focus ? {
                        onFocus: function onFocus(_ref2) {
                            var target = _ref2.target;
                            return target.select();
                        }
                    } : {}));
                }
            } ]);
            return TextArea;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = TextArea;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var clsx__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
        var _components_units_list__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(78);
        var _slider__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(174);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Number = function(_Slider) {
            _inherits(Number, _Slider);
            var _super = _createSuper(Number);
            function Number() {
                _classCallCheck(this, Number);
                return _super.apply(this, arguments);
            }
            _createClass(Number, [ {
                key: "render",
                value: function render() {
                    var _clsx, _this = this;
                    var options = this.props.options;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_0__["default"])("lotta-number", (_clsx = {}, 
                        _defineProperty(_clsx, "lotta-value-changer", true), _defineProperty(_clsx, "no-unit-list", !this.hasUnitsList()), 
                        _defineProperty(_clsx, "no-unit", !(this.hasUnitsList() || this.props.options.defaultUnit !== false)), 
                        _defineProperty(_clsx, "active", this.state.isUnitsListOpen), _clsx)),
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("input", _objectSpread(_objectSpread({
                            type: "number"
                        }, this.props.options.ref ? {
                            ref: this.props.options.ref
                        } : {}), {}, {
                            step: 1 / Math.pow(10, this.getAllowedDecimalPlaces()),
                            value: this.getNumericValue(),
                            onBlur: function onBlur() {
                                return _this.handleBlur();
                            },
                            onChange: function onChange(_ref) {
                                var value = _ref.target.value;
                                return _this.handleChange(value);
                            }
                        }, options.select_on_focus ? {
                            onFocus: function onFocus(_ref2) {
                                var target = _ref2.target;
                                target.select();
                            }
                        } : {})), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                            className: "lotta-value-divider"
                        }), !this.hasUnitsList() && this.props.options.defaultUnit !== false && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                            className: "lotta-current-value",
                            children: this.withDefault(this.getCurrentUnit(), this.props.options.defaultUnit || "px")
                        }), this.hasUnitsList() && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_components_units_list__WEBPACK_IMPORTED_MODULE_1__["default"], {
                            units: this.props.options.units,
                            onChange: this.props.onChange,
                            isOpen: this.state.isUnitsListOpen,
                            toggleOpen: function toggleOpen() {
                                return _this.setState({
                                    isUnitsListOpen: !_this.state.isUnitsListOpen
                                });
                            },
                            currentUnit: this.getCurrentUnit(),
                            getNumericValue: this.getNumericValue,
                            getAllowedDecimalPlaces: this.getAllowedDecimalPlaces
                        }) ]
                    });
                }
            } ]);
            return Number;
        }(_slider__WEBPACK_IMPORTED_MODULE_2__["default"]);
        _defineProperty(Number, "renderingConfig", {
            design: "inline"
        });
        const __WEBPACK_DEFAULT_EXPORT__ = Number;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
        var react_outside_click_handler__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        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);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        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;
        }
        var UnitsList = function UnitsList(props) {
            var units = props.units, onChange = props.onChange, onPickUnit = props.onPickUnit, isOpen = props.isOpen, toggleOpen = props.toggleOpen, currentUnit = props.currentUnit, getNumericValue = props.getNumericValue, getAllowedDecimalPlaces = props.getAllowedDecimalPlaces;
            var pickUnit = onPickUnit || function(unit) {
                var numericValue = getNumericValue();
                onChange("".concat((0, _utils__WEBPACK_IMPORTED_MODULE_0__.round)((0, _utils__WEBPACK_IMPORTED_MODULE_0__.clamp)(units.find((function(_ref) {
                    var u = _ref.unit;
                    return u === unit;
                })).min, units.find((function(_ref2) {
                    var u = _ref2.unit;
                    return u === unit;
                })).max, numericValue === "" ? -Infinity : numericValue), getAllowedDecimalPlaces(unit))).concat(unit));
            };
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__.Fragment, {
                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                    onClick: function onClick() {
                        return toggleOpen();
                    },
                    className: "lotta-current-value",
                    children: currentUnit || "―"
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(react_outside_click_handler__WEBPACK_IMPORTED_MODULE_1__["default"], {
                    onOutsideClick: function onOutsideClick() {
                        if (!isOpen) {
                            return;
                        }
                        toggleOpen();
                    },
                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("ul", {
                        className: "lotta-units-list",
                        children: units.filter((function(_ref3) {
                            var unit = _ref3.unit;
                            return unit !== currentUnit;
                        })).reduce((function(current, el, index) {
                            return [].concat(_toConsumableArray(current.slice(0, index % 2 === 0 ? undefined : -1)), _toConsumableArray(index % 2 === 0 ? [ [ el ] ] : [ [ current[current.length - 1][0], el ] ]));
                        }), []).map((function(group) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("li", {
                                children: group.map((function(_ref4) {
                                    var unit = _ref4.unit;
                                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                                        onClick: function onClick() {
                                            pickUnit(unit);
                                            toggleOpen();
                                        },
                                        children: unit || "―"
                                    }, unit);
                                }))
                            }, group[0].unit);
                        }))
                    })
                }) ]
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = UnitsList;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        module.exports = __webpack_require__(80);
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        var _createClass = function() {
            function defineProperties(target, props) {
                for (var i = 0; i < props.length; i++) {
                    var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true;
                    if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor);
                }
            }
            return function(Constructor, protoProps, staticProps) {
                if (protoProps) defineProperties(Constructor.prototype, protoProps);
                if (staticProps) defineProperties(Constructor, staticProps);
                return Constructor;
            };
        }();
        var _react = __webpack_require__(12);
        var _react2 = _interopRequireDefault(_react);
        var _propTypes = __webpack_require__(81);
        var _propTypes2 = _interopRequireDefault(_propTypes);
        var _airbnbPropTypes = __webpack_require__(88);
        var _consolidatedEvents = __webpack_require__(165);
        var _object = __webpack_require__(166);
        var _object2 = _interopRequireDefault(_object);
        var _document = __webpack_require__(170);
        var _document2 = _interopRequireDefault(_document);
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _possibleConstructorReturn(self, call) {
            if (!self) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return call && (typeof call === "object" || typeof call === "function") ? call : self;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    enumerable: false,
                    writable: true,
                    configurable: true
                }
            });
            if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
        }
        var DISPLAY = {
            BLOCK: "block",
            FLEX: "flex",
            INLINE: "inline",
            INLINE_BLOCK: "inline-block",
            CONTENTS: "contents"
        };
        var propTypes = (0, _airbnbPropTypes.forbidExtraProps)({
            children: _propTypes2["default"].node.isRequired,
            onOutsideClick: _propTypes2["default"].func.isRequired,
            disabled: _propTypes2["default"].bool,
            useCapture: _propTypes2["default"].bool,
            display: _propTypes2["default"].oneOf((0, _object2["default"])(DISPLAY))
        });
        var defaultProps = {
            disabled: false,
            useCapture: true,
            display: DISPLAY.BLOCK
        };
        var OutsideClickHandler = function(_React$Component) {
            _inherits(OutsideClickHandler, _React$Component);
            function OutsideClickHandler() {
                var _ref;
                _classCallCheck(this, OutsideClickHandler);
                for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                var _this = _possibleConstructorReturn(this, (_ref = OutsideClickHandler.__proto__ || Object.getPrototypeOf(OutsideClickHandler)).call.apply(_ref, [ this ].concat(args)));
                _this.onMouseDown = _this.onMouseDown.bind(_this);
                _this.onMouseUp = _this.onMouseUp.bind(_this);
                _this.setChildNodeRef = _this.setChildNodeRef.bind(_this);
                return _this;
            }
            _createClass(OutsideClickHandler, [ {
                key: "componentDidMount",
                value: function() {
                    function componentDidMount() {
                        var _props = this.props, disabled = _props.disabled, useCapture = _props.useCapture;
                        if (!disabled) this.addMouseDownEventListener(useCapture);
                    }
                    return componentDidMount;
                }()
            }, {
                key: "componentDidUpdate",
                value: function() {
                    function componentDidUpdate(_ref2) {
                        var prevDisabled = _ref2.disabled;
                        var _props2 = this.props, disabled = _props2.disabled, useCapture = _props2.useCapture;
                        if (prevDisabled !== disabled) {
                            if (disabled) {
                                this.removeEventListeners();
                            } else {
                                this.addMouseDownEventListener(useCapture);
                            }
                        }
                    }
                    return componentDidUpdate;
                }()
            }, {
                key: "componentWillUnmount",
                value: function() {
                    function componentWillUnmount() {
                        this.removeEventListeners();
                    }
                    return componentWillUnmount;
                }()
            }, {
                key: "onMouseDown",
                value: function() {
                    function onMouseDown(e) {
                        var useCapture = this.props.useCapture;
                        var isDescendantOfRoot = this.childNode && (0, _document2["default"])(this.childNode, e.target);
                        if (!isDescendantOfRoot) {
                            if (this.removeMouseUp) {
                                this.removeMouseUp();
                                this.removeMouseUp = null;
                            }
                            this.removeMouseUp = (0, _consolidatedEvents.addEventListener)(document, "mouseup", this.onMouseUp, {
                                capture: useCapture
                            });
                        }
                    }
                    return onMouseDown;
                }()
            }, {
                key: "onMouseUp",
                value: function() {
                    function onMouseUp(e) {
                        var onOutsideClick = this.props.onOutsideClick;
                        var isDescendantOfRoot = this.childNode && (0, _document2["default"])(this.childNode, e.target);
                        if (this.removeMouseUp) {
                            this.removeMouseUp();
                            this.removeMouseUp = null;
                        }
                        if (!isDescendantOfRoot) {
                            onOutsideClick(e);
                        }
                    }
                    return onMouseUp;
                }()
            }, {
                key: "setChildNodeRef",
                value: function() {
                    function setChildNodeRef(ref) {
                        this.childNode = ref;
                    }
                    return setChildNodeRef;
                }()
            }, {
                key: "addMouseDownEventListener",
                value: function() {
                    function addMouseDownEventListener(useCapture) {
                        this.removeMouseDown = (0, _consolidatedEvents.addEventListener)(document, "mousedown", this.onMouseDown, {
                            capture: useCapture
                        });
                    }
                    return addMouseDownEventListener;
                }()
            }, {
                key: "removeEventListeners",
                value: function() {
                    function removeEventListeners() {
                        if (this.removeMouseDown) this.removeMouseDown();
                        if (this.removeMouseUp) this.removeMouseUp();
                    }
                    return removeEventListeners;
                }()
            }, {
                key: "render",
                value: function() {
                    function render() {
                        var _props3 = this.props, children = _props3.children, display = _props3.display;
                        return _react2["default"].createElement("div", {
                            ref: this.setChildNodeRef,
                            style: display !== DISPLAY.BLOCK && (0, _object2["default"])(DISPLAY).includes(display) ? {
                                display
                            } : undefined
                        }, children);
                    }
                    return render;
                }()
            } ]);
            return OutsideClickHandler;
        }(_react2["default"].Component);
        exports["default"] = OutsideClickHandler;
        OutsideClickHandler.propTypes = propTypes;
        OutsideClickHandler.defaultProps = defaultProps;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        if (true) {
            var ReactIs = __webpack_require__(82);
            var throwOnDirectAccess = true;
            module.exports = __webpack_require__(84)(ReactIs.isElement, throwOnDirectAccess);
        } else {}
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        if (false) {} else {
            module.exports = __webpack_require__(83);
        }
    }, (__unused_webpack_module, exports) => {
        "use strict";
        /** @license React v16.13.1
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */        if (true) {
            (function() {
                "use strict";
                var hasSymbol = typeof Symbol === "function" && Symbol.for;
                var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
                var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
                var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
                var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
                var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
                var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
                var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
                var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
                var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
                var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
                var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
                var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
                var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
                var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
                var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
                var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
                var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
                var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
                function isValidElementType(type) {
                    return typeof type === "string" || typeof type === "function" || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
                }
                function typeOf(object) {
                    if (typeof object === "object" && object !== null) {
                        var $$typeof = object.$$typeof;
                        switch ($$typeof) {
                          case REACT_ELEMENT_TYPE:
                            var type = object.type;
                            switch (type) {
                              case REACT_ASYNC_MODE_TYPE:
                              case REACT_CONCURRENT_MODE_TYPE:
                              case REACT_FRAGMENT_TYPE:
                              case REACT_PROFILER_TYPE:
                              case REACT_STRICT_MODE_TYPE:
                              case REACT_SUSPENSE_TYPE:
                                return type;

                              default:
                                var $$typeofType = type && type.$$typeof;
                                switch ($$typeofType) {
                                  case REACT_CONTEXT_TYPE:
                                  case REACT_FORWARD_REF_TYPE:
                                  case REACT_LAZY_TYPE:
                                  case REACT_MEMO_TYPE:
                                  case REACT_PROVIDER_TYPE:
                                    return $$typeofType;

                                  default:
                                    return $$typeof;
                                }
                            }

                          case REACT_PORTAL_TYPE:
                            return $$typeof;
                        }
                    }
                    return undefined;
                }
                var AsyncMode = REACT_ASYNC_MODE_TYPE;
                var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
                var ContextConsumer = REACT_CONTEXT_TYPE;
                var ContextProvider = REACT_PROVIDER_TYPE;
                var Element = REACT_ELEMENT_TYPE;
                var ForwardRef = REACT_FORWARD_REF_TYPE;
                var Fragment = REACT_FRAGMENT_TYPE;
                var Lazy = REACT_LAZY_TYPE;
                var Memo = REACT_MEMO_TYPE;
                var Portal = REACT_PORTAL_TYPE;
                var Profiler = REACT_PROFILER_TYPE;
                var StrictMode = REACT_STRICT_MODE_TYPE;
                var Suspense = REACT_SUSPENSE_TYPE;
                var hasWarnedAboutDeprecatedIsAsyncMode = false;
                function isAsyncMode(object) {
                    {
                        if (!hasWarnedAboutDeprecatedIsAsyncMode) {
                            hasWarnedAboutDeprecatedIsAsyncMode = true;
                            console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, " + "and will be removed in React 17+. Update your code to use " + "ReactIs.isConcurrentMode() instead. It has the exact same API.");
                        }
                    }
                    return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
                }
                function isConcurrentMode(object) {
                    return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
                }
                function isContextConsumer(object) {
                    return typeOf(object) === REACT_CONTEXT_TYPE;
                }
                function isContextProvider(object) {
                    return typeOf(object) === REACT_PROVIDER_TYPE;
                }
                function isElement(object) {
                    return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
                }
                function isForwardRef(object) {
                    return typeOf(object) === REACT_FORWARD_REF_TYPE;
                }
                function isFragment(object) {
                    return typeOf(object) === REACT_FRAGMENT_TYPE;
                }
                function isLazy(object) {
                    return typeOf(object) === REACT_LAZY_TYPE;
                }
                function isMemo(object) {
                    return typeOf(object) === REACT_MEMO_TYPE;
                }
                function isPortal(object) {
                    return typeOf(object) === REACT_PORTAL_TYPE;
                }
                function isProfiler(object) {
                    return typeOf(object) === REACT_PROFILER_TYPE;
                }
                function isStrictMode(object) {
                    return typeOf(object) === REACT_STRICT_MODE_TYPE;
                }
                function isSuspense(object) {
                    return typeOf(object) === REACT_SUSPENSE_TYPE;
                }
                exports.AsyncMode = AsyncMode;
                exports.ConcurrentMode = ConcurrentMode;
                exports.ContextConsumer = ContextConsumer;
                exports.ContextProvider = ContextProvider;
                exports.Element = Element;
                exports.ForwardRef = ForwardRef;
                exports.Fragment = Fragment;
                exports.Lazy = Lazy;
                exports.Memo = Memo;
                exports.Portal = Portal;
                exports.Profiler = Profiler;
                exports.StrictMode = StrictMode;
                exports.Suspense = Suspense;
                exports.isAsyncMode = isAsyncMode;
                exports.isConcurrentMode = isConcurrentMode;
                exports.isContextConsumer = isContextConsumer;
                exports.isContextProvider = isContextProvider;
                exports.isElement = isElement;
                exports.isForwardRef = isForwardRef;
                exports.isFragment = isFragment;
                exports.isLazy = isLazy;
                exports.isMemo = isMemo;
                exports.isPortal = isPortal;
                exports.isProfiler = isProfiler;
                exports.isStrictMode = isStrictMode;
                exports.isSuspense = isSuspense;
                exports.isValidElementType = isValidElementType;
                exports.typeOf = typeOf;
            })();
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var ReactIs = __webpack_require__(82);
        var assign = __webpack_require__(13);
        var ReactPropTypesSecret = __webpack_require__(85);
        var has = __webpack_require__(86);
        var checkPropTypes = __webpack_require__(87);
        var printWarning = function() {};
        if (true) {
            printWarning = function(text) {
                var message = "Warning: " + text;
                if (typeof console !== "undefined") {
                    console.error(message);
                }
                try {
                    throw new Error(message);
                } catch (x) {}
            };
        }
        function emptyFunctionThatReturnsNull() {
            return null;
        }
        module.exports = function(isValidElement, throwOnDirectAccess) {
            var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
            var FAUX_ITERATOR_SYMBOL = "@@iterator";
            function getIteratorFn(maybeIterable) {
                var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
                if (typeof iteratorFn === "function") {
                    return iteratorFn;
                }
            }
            var ANONYMOUS = "<<anonymous>>";
            var ReactPropTypes = {
                array: createPrimitiveTypeChecker("array"),
                bigint: createPrimitiveTypeChecker("bigint"),
                bool: createPrimitiveTypeChecker("boolean"),
                func: createPrimitiveTypeChecker("function"),
                number: createPrimitiveTypeChecker("number"),
                object: createPrimitiveTypeChecker("object"),
                string: createPrimitiveTypeChecker("string"),
                symbol: createPrimitiveTypeChecker("symbol"),
                any: createAnyTypeChecker(),
                arrayOf: createArrayOfTypeChecker,
                element: createElementTypeChecker(),
                elementType: createElementTypeTypeChecker(),
                instanceOf: createInstanceTypeChecker,
                node: createNodeChecker(),
                objectOf: createObjectOfTypeChecker,
                oneOf: createEnumTypeChecker,
                oneOfType: createUnionTypeChecker,
                shape: createShapeTypeChecker,
                exact: createStrictShapeTypeChecker
            };
            function is(x, y) {
                if (x === y) {
                    return x !== 0 || 1 / x === 1 / y;
                } else {
                    return x !== x && y !== y;
                }
            }
            function PropTypeError(message, data) {
                this.message = message;
                this.data = data && typeof data === "object" ? data : {};
                this.stack = "";
            }
            PropTypeError.prototype = Error.prototype;
            function createChainableTypeChecker(validate) {
                if (true) {
                    var manualPropTypeCallCache = {};
                    var manualPropTypeWarningCount = 0;
                }
                function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
                    componentName = componentName || ANONYMOUS;
                    propFullName = propFullName || propName;
                    if (secret !== ReactPropTypesSecret) {
                        if (throwOnDirectAccess) {
                            var err = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. " + "Use `PropTypes.checkPropTypes()` to call them. " + "Read more at http://fb.me/use-check-prop-types");
                            err.name = "Invariant Violation";
                            throw err;
                        } else if (true && typeof console !== "undefined") {
                            var cacheKey = componentName + ":" + propName;
                            if (!manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3) {
                                printWarning("You are manually calling a React.PropTypes validation " + "function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated " + "and will throw in the standalone `prop-types` package. " + "You may be seeing this warning due to a third-party PropTypes " + "library. See https://fb.me/react-warning-dont-call-proptypes " + "for details.");
                                manualPropTypeCallCache[cacheKey] = true;
                                manualPropTypeWarningCount++;
                            }
                        }
                    }
                    if (props[propName] == null) {
                        if (isRequired) {
                            if (props[propName] === null) {
                                return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`."));
                            }
                            return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`."));
                        }
                        return null;
                    } else {
                        return validate(props, propName, componentName, location, propFullName);
                    }
                }
                var chainedCheckType = checkType.bind(null, false);
                chainedCheckType.isRequired = checkType.bind(null, true);
                return chainedCheckType;
            }
            function createPrimitiveTypeChecker(expectedType) {
                function validate(props, propName, componentName, location, propFullName, secret) {
                    var propValue = props[propName];
                    var propType = getPropType(propValue);
                    if (propType !== expectedType) {
                        var preciseType = getPreciseType(propValue);
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."), {
                            expectedType
                        });
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createAnyTypeChecker() {
                return createChainableTypeChecker(emptyFunctionThatReturnsNull);
            }
            function createArrayOfTypeChecker(typeChecker) {
                function validate(props, propName, componentName, location, propFullName) {
                    if (typeof typeChecker !== "function") {
                        return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
                    }
                    var propValue = props[propName];
                    if (!Array.isArray(propValue)) {
                        var propType = getPropType(propValue);
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
                    }
                    for (var i = 0; i < propValue.length; i++) {
                        var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
                        if (error instanceof Error) {
                            return error;
                        }
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createElementTypeChecker() {
                function validate(props, propName, componentName, location, propFullName) {
                    var propValue = props[propName];
                    if (!isValidElement(propValue)) {
                        var propType = getPropType(propValue);
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createElementTypeTypeChecker() {
                function validate(props, propName, componentName, location, propFullName) {
                    var propValue = props[propName];
                    if (!ReactIs.isValidElementType(propValue)) {
                        var propType = getPropType(propValue);
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createInstanceTypeChecker(expectedClass) {
                function validate(props, propName, componentName, location, propFullName) {
                    if (!(props[propName] instanceof expectedClass)) {
                        var expectedClassName = expectedClass.name || ANONYMOUS;
                        var actualClassName = getClassName(props[propName]);
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createEnumTypeChecker(expectedValues) {
                if (!Array.isArray(expectedValues)) {
                    if (true) {
                        if (arguments.length > 1) {
                            printWarning("Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. " + "A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).");
                        } else {
                            printWarning("Invalid argument supplied to oneOf, expected an array.");
                        }
                    }
                    return emptyFunctionThatReturnsNull;
                }
                function validate(props, propName, componentName, location, propFullName) {
                    var propValue = props[propName];
                    for (var i = 0; i < expectedValues.length; i++) {
                        if (is(propValue, expectedValues[i])) {
                            return null;
                        }
                    }
                    var valuesString = JSON.stringify(expectedValues, (function replacer(key, value) {
                        var type = getPreciseType(value);
                        if (type === "symbol") {
                            return String(value);
                        }
                        return value;
                    }));
                    return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
                }
                return createChainableTypeChecker(validate);
            }
            function createObjectOfTypeChecker(typeChecker) {
                function validate(props, propName, componentName, location, propFullName) {
                    if (typeof typeChecker !== "function") {
                        return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
                    }
                    var propValue = props[propName];
                    var propType = getPropType(propValue);
                    if (propType !== "object") {
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
                    }
                    for (var key in propValue) {
                        if (has(propValue, key)) {
                            var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
                            if (error instanceof Error) {
                                return error;
                            }
                        }
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createUnionTypeChecker(arrayOfTypeCheckers) {
                if (!Array.isArray(arrayOfTypeCheckers)) {
                    true ? printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") : 0;
                    return emptyFunctionThatReturnsNull;
                }
                for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
                    var checker = arrayOfTypeCheckers[i];
                    if (typeof checker !== "function") {
                        printWarning("Invalid argument supplied to oneOfType. Expected an array of check functions, but " + "received " + getPostfixForTypeWarning(checker) + " at index " + i + ".");
                        return emptyFunctionThatReturnsNull;
                    }
                }
                function validate(props, propName, componentName, location, propFullName) {
                    var expectedTypes = [];
                    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
                        var checker = arrayOfTypeCheckers[i];
                        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
                        if (checkerResult == null) {
                            return null;
                        }
                        if (checkerResult.data && has(checkerResult.data, "expectedType")) {
                            expectedTypes.push(checkerResult.data.expectedType);
                        }
                    }
                    var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
                    return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
                }
                return createChainableTypeChecker(validate);
            }
            function createNodeChecker() {
                function validate(props, propName, componentName, location, propFullName) {
                    if (!isNode(props[propName])) {
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function invalidValidatorError(componentName, location, propFullName, key, type) {
                return new PropTypeError((componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + type + "`.");
            }
            function createShapeTypeChecker(shapeTypes) {
                function validate(props, propName, componentName, location, propFullName) {
                    var propValue = props[propName];
                    var propType = getPropType(propValue);
                    if (propType !== "object") {
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
                    }
                    for (var key in shapeTypes) {
                        var checker = shapeTypes[key];
                        if (typeof checker !== "function") {
                            return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
                        }
                        var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
                        if (error) {
                            return error;
                        }
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function createStrictShapeTypeChecker(shapeTypes) {
                function validate(props, propName, componentName, location, propFullName) {
                    var propValue = props[propName];
                    var propType = getPropType(propValue);
                    if (propType !== "object") {
                        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
                    }
                    var allKeys = assign({}, props[propName], shapeTypes);
                    for (var key in allKeys) {
                        var checker = shapeTypes[key];
                        if (has(shapeTypes, key) && typeof checker !== "function") {
                            return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
                        }
                        if (!checker) {
                            return new PropTypeError("Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`." + "\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  "));
                        }
                        var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
                        if (error) {
                            return error;
                        }
                    }
                    return null;
                }
                return createChainableTypeChecker(validate);
            }
            function isNode(propValue) {
                switch (typeof propValue) {
                  case "number":
                  case "string":
                  case "undefined":
                    return true;

                  case "boolean":
                    return !propValue;

                  case "object":
                    if (Array.isArray(propValue)) {
                        return propValue.every(isNode);
                    }
                    if (propValue === null || isValidElement(propValue)) {
                        return true;
                    }
                    var iteratorFn = getIteratorFn(propValue);
                    if (iteratorFn) {
                        var iterator = iteratorFn.call(propValue);
                        var step;
                        if (iteratorFn !== propValue.entries) {
                            while (!(step = iterator.next()).done) {
                                if (!isNode(step.value)) {
                                    return false;
                                }
                            }
                        } else {
                            while (!(step = iterator.next()).done) {
                                var entry = step.value;
                                if (entry) {
                                    if (!isNode(entry[1])) {
                                        return false;
                                    }
                                }
                            }
                        }
                    } else {
                        return false;
                    }
                    return true;

                  default:
                    return false;
                }
            }
            function isSymbol(propType, propValue) {
                if (propType === "symbol") {
                    return true;
                }
                if (!propValue) {
                    return false;
                }
                if (propValue["@@toStringTag"] === "Symbol") {
                    return true;
                }
                if (typeof Symbol === "function" && propValue instanceof Symbol) {
                    return true;
                }
                return false;
            }
            function getPropType(propValue) {
                var propType = typeof propValue;
                if (Array.isArray(propValue)) {
                    return "array";
                }
                if (propValue instanceof RegExp) {
                    return "object";
                }
                if (isSymbol(propType, propValue)) {
                    return "symbol";
                }
                return propType;
            }
            function getPreciseType(propValue) {
                if (typeof propValue === "undefined" || propValue === null) {
                    return "" + propValue;
                }
                var propType = getPropType(propValue);
                if (propType === "object") {
                    if (propValue instanceof Date) {
                        return "date";
                    } else if (propValue instanceof RegExp) {
                        return "regexp";
                    }
                }
                return propType;
            }
            function getPostfixForTypeWarning(value) {
                var type = getPreciseType(value);
                switch (type) {
                  case "array":
                  case "object":
                    return "an " + type;

                  case "boolean":
                  case "date":
                  case "regexp":
                    return "a " + type;

                  default:
                    return type;
                }
            }
            function getClassName(propValue) {
                if (!propValue.constructor || !propValue.constructor.name) {
                    return ANONYMOUS;
                }
                return propValue.constructor.name;
            }
            ReactPropTypes.checkPropTypes = checkPropTypes;
            ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
            ReactPropTypes.PropTypes = ReactPropTypes;
            return ReactPropTypes;
        };
    }, module => {
        "use strict";
        var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
        module.exports = ReactPropTypesSecret;
    }, module => {
        module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var printWarning = function() {};
        if (true) {
            var ReactPropTypesSecret = __webpack_require__(85);
            var loggedTypeFailures = {};
            var has = __webpack_require__(86);
            printWarning = function(text) {
                var message = "Warning: " + text;
                if (typeof console !== "undefined") {
                    console.error(message);
                }
                try {
                    throw new Error(message);
                } catch (x) {}
            };
        }
        function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
            if (true) {
                for (var typeSpecName in typeSpecs) {
                    if (has(typeSpecs, typeSpecName)) {
                        var error;
                        try {
                            if (typeof typeSpecs[typeSpecName] !== "function") {
                                var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
                                err.name = "Invariant Violation";
                                throw err;
                            }
                            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
                        } catch (ex) {
                            error = ex;
                        }
                        if (error && !(error instanceof Error)) {
                            printWarning((componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker " + "function must return `null` or an `Error` but returned a " + typeof error + ". " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).");
                        }
                        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
                            loggedTypeFailures[error.message] = true;
                            var stack = getStack ? getStack() : "";
                            printWarning("Failed " + location + " type: " + error.message + (stack != null ? stack : ""));
                        }
                    }
                }
            }
        }
        checkPropTypes.resetWarningCache = function() {
            if (true) {
                loggedTypeFailures = {};
            }
        };
        module.exports = checkPropTypes;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        module.exports = false ? 0 : __webpack_require__(89);
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var _propTypesExact = _interopRequireDefault(__webpack_require__(90));
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _between = _interopRequireDefault(__webpack_require__(94));
        var _booleanSome = _interopRequireDefault(__webpack_require__(105));
        var _childrenHavePropXorChildren = _interopRequireDefault(__webpack_require__(106));
        var _childrenOf = _interopRequireDefault(__webpack_require__(107));
        var _childrenOfType = _interopRequireDefault(__webpack_require__(109));
        var _childrenSequenceOf = _interopRequireDefault(__webpack_require__(136));
        var _componentWithName = _interopRequireDefault(__webpack_require__(145));
        var _disallowedIf = _interopRequireDefault(__webpack_require__(146));
        var _elementType = _interopRequireDefault(__webpack_require__(147));
        var _empty = _interopRequireDefault(__webpack_require__(148));
        var _explicitNull = _interopRequireDefault(__webpack_require__(150));
        var _integer = _interopRequireDefault(__webpack_require__(139));
        var _keysOf = _interopRequireDefault(__webpack_require__(151));
        var _mutuallyExclusiveProps = _interopRequireDefault(__webpack_require__(152));
        var _mutuallyExclusiveTrueProps = _interopRequireDefault(__webpack_require__(153));
        var _nChildren = _interopRequireDefault(__webpack_require__(154));
        var _nonNegativeInteger = _interopRequireDefault(__webpack_require__(138));
        var _nonNegativeNumber = _interopRequireDefault(__webpack_require__(141));
        var _numericString = _interopRequireDefault(__webpack_require__(155));
        var _object = _interopRequireDefault(__webpack_require__(142));
        var _or = _interopRequireDefault(__webpack_require__(149));
        var _predicate = _interopRequireDefault(__webpack_require__(156));
        var _range = _interopRequireDefault(__webpack_require__(157));
        var _ref = _interopRequireDefault(__webpack_require__(158));
        var _requiredBy = _interopRequireDefault(__webpack_require__(159));
        var _restrictedProp = _interopRequireDefault(__webpack_require__(160));
        var _sequenceOf = _interopRequireDefault(__webpack_require__(137));
        var _shape = _interopRequireDefault(__webpack_require__(101));
        var _stringEndsWith = _interopRequireDefault(__webpack_require__(161));
        var _stringStartsWith = _interopRequireDefault(__webpack_require__(162));
        var _uniqueArray = _interopRequireDefault(__webpack_require__(163));
        var _uniqueArrayOf = _interopRequireDefault(__webpack_require__(164));
        var _valuesOf = _interopRequireDefault(__webpack_require__(103));
        var _withShape = _interopRequireDefault(__webpack_require__(144));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        module.exports = {
            and: _and["default"],
            between: _between["default"],
            booleanSome: _booleanSome["default"],
            childrenHavePropXorChildren: _childrenHavePropXorChildren["default"],
            childrenOf: _childrenOf["default"],
            childrenOfType: _childrenOfType["default"],
            childrenSequenceOf: _childrenSequenceOf["default"],
            componentWithName: _componentWithName["default"],
            disallowedIf: _disallowedIf["default"],
            elementType: _elementType["default"],
            empty: _empty["default"],
            explicitNull: _explicitNull["default"],
            forbidExtraProps: _propTypesExact["default"],
            integer: _integer["default"],
            keysOf: _keysOf["default"],
            mutuallyExclusiveProps: _mutuallyExclusiveProps["default"],
            mutuallyExclusiveTrueProps: _mutuallyExclusiveTrueProps["default"],
            nChildren: _nChildren["default"],
            nonNegativeInteger: _nonNegativeInteger["default"],
            nonNegativeNumber: _nonNegativeNumber["default"],
            numericString: _numericString["default"],
            object: _object["default"],
            or: _or["default"],
            predicate: _predicate["default"],
            range: _range["default"],
            ref: _ref["default"],
            requiredBy: _requiredBy["default"],
            restrictedProp: _restrictedProp["default"],
            sequenceOf: _sequenceOf["default"],
            shape: _shape["default"],
            stringEndsWith: _stringEndsWith["default"],
            stringStartsWith: _stringStartsWith["default"],
            uniqueArray: _uniqueArray["default"],
            uniqueArrayOf: _uniqueArrayOf["default"],
            valuesOf: _valuesOf["default"],
            withShape: _withShape["default"]
        };
    }, (module, exports, __webpack_require__) => {
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = forbidExtraProps;
        var _object = __webpack_require__(66);
        var _object2 = _interopRequireDefault(_object);
        var _has = __webpack_require__(26);
        var _has2 = _interopRequireDefault(_has);
        var _isPlainObject = __webpack_require__(91);
        var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var zeroWidthSpace = "​";
        var specialProperty = "prop-types-exact: " + zeroWidthSpace;
        var semaphore = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"](specialProperty) : specialProperty;
        function brand(fn) {
            return (0, _object2["default"])(fn, _defineProperty({}, specialProperty, semaphore));
        }
        function isBranded(value) {
            return value && value[specialProperty] === semaphore;
        }
        function forbidExtraProps(propTypes) {
            if (!(0, _isPlainObject2["default"])(propTypes)) {
                throw new TypeError("given propTypes must be an object");
            }
            if ((0, _has2["default"])(propTypes, specialProperty) && !isBranded(propTypes[specialProperty])) {
                throw new TypeError("Against all odds, you created a propType for a prop that uses both the zero-width space and our custom string - which, sadly, conflicts with `prop-types-exact`");
            }
            return (0, _object2["default"])({}, propTypes, _defineProperty({}, specialProperty, brand(function() {
                function forbidUnknownProps(props, _, componentName) {
                    var unknownProps = Object.keys(props).filter((function(prop) {
                        return !(0, _has2["default"])(propTypes, prop);
                    }));
                    if (unknownProps.length > 0) {
                        return new TypeError(String(componentName) + ": unknown props found: " + String(unknownProps.join(", ")));
                    }
                    return null;
                }
                return forbidUnknownProps;
            }())));
        }
        module.exports = exports["default"];
    }, (module, exports) => {
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
            return typeof obj;
        } : function(obj) {
            return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
        };
        exports["default"] = isPlainObject;
        function isPlainObject(x) {
            return x && (typeof x === "undefined" ? "undefined" : _typeof(x)) === "object" && !Array.isArray(x);
        }
        module.exports = exports["default"];
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = andValidator;
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function andValidator(validators) {
            var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "and";
            if (!Array.isArray(validators)) {
                throw new TypeError("and: 2 or more validators are required");
            }
            if (validators.length <= 1) {
                throw new RangeError("and: 2 or more validators are required");
            }
            var validator = function and() {
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                var firstError = null;
                validators.some((function(validatorFn) {
                    firstError = validatorFn.apply(void 0, args);
                    return firstError != null;
                }));
                return firstError == null ? null : firstError;
            };
            validator.isRequired = function andIsRequired() {
                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                    args[_key2] = arguments[_key2];
                }
                var firstError = null;
                validators.some((function(validatorFn) {
                    firstError = validatorFn.isRequired.apply(validatorFn, args);
                    return firstError != null;
                }));
                return firstError == null ? null : firstError;
            };
            return (0, _wrapValidator["default"])(validator, name, validators);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = wrapValidator;
        var _object = _interopRequireDefault(__webpack_require__(66));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function wrapValidator(validator, typeName) {
            var typeChecker = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
            return (0, _object["default"])(validator.bind(), {
                typeName,
                typeChecker,
                isRequired: (0, _object["default"])(validator.isRequired.bind(), {
                    typeName,
                    typeChecker,
                    typeRequired: true
                })
            });
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = betweenValidator;
        var _object = _interopRequireDefault(__webpack_require__(95));
        var _shape = _interopRequireDefault(__webpack_require__(101));
        var _valuesOf = _interopRequireDefault(__webpack_require__(103));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function _typeof(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function _typeof(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }));
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _e = undefined;
            try {
                for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function number(props, propName, componentName) {
            var value = props[propName];
            if (typeof value === "number" && !isNaN(value)) {
                return null;
            }
            return new TypeError("".concat(componentName, ": ").concat(propName, " must be a non-NaN number."));
        }
        function numberOrPropsFunc(props, propName) {
            var value = props[propName];
            if (typeof value === "function") {
                return null;
            }
            if (typeof value === "number" && !isNaN(value)) {
                return null;
            }
            return new TypeError("".concat(propName, ": a function, or a non-NaN number is required"));
        }
        function lowerCompare(value, _ref) {
            var gt = _ref.gt, gte = _ref.gte;
            if (typeof gt === "number") {
                return value > gt;
            }
            if (typeof gte === "number") {
                return value >= gte;
            }
            return true;
        }
        function upperCompare(value, _ref2) {
            var lt = _ref2.lt, lte = _ref2.lte;
            if (typeof lt === "number") {
                return value < lt;
            }
            if (typeof lte === "number") {
                return value <= lte;
            }
            return true;
        }
        function greaterThanError(_ref3) {
            var gt = _ref3.gt, gte = _ref3.gte;
            if (typeof gt === "number") {
                return "greater than ".concat(gt);
            }
            if (typeof gte === "number") {
                return "greater than or equal to ".concat(gte);
            }
            return "";
        }
        function lessThanError(_ref4) {
            var lt = _ref4.lt, lte = _ref4.lte;
            if (typeof lt === "number") {
                return "less than ".concat(lt);
            }
            if (typeof lte === "number") {
                return "less than or equal to ".concat(lte);
            }
            return "";
        }
        function errorMessage(componentName, propName, opts) {
            var errors = [ greaterThanError(opts), lessThanError(opts) ].filter(Boolean).join(" and ");
            return "".concat(componentName, ": ").concat(propName, " must be ").concat(errors);
        }
        function propsThunkify(opts) {
            return (0, _object["default"])(opts).reduce((function(acc, _ref5) {
                var _ref6 = _slicedToArray(_ref5, 2), key = _ref6[0], value = _ref6[1];
                var numberThunk = typeof value === "number" ? function() {
                    return value;
                } : value;
                return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, key, numberThunk));
            }), {});
        }
        function invokeWithProps(optsThunks, props) {
            return (0, _object["default"])(optsThunks).reduce((function(acc, _ref7) {
                var _ref8 = _slicedToArray(_ref7, 2), key = _ref8[0], thunk = _ref8[1];
                var value = thunk(props);
                return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, key, value));
            }), {});
        }
        var argValidators = [ (0, _shape["default"])({
            lt: numberOrPropsFunc,
            gt: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            lte: numberOrPropsFunc,
            gt: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            lt: numberOrPropsFunc,
            gte: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            lte: numberOrPropsFunc,
            gte: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            lt: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            lte: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            gt: numberOrPropsFunc
        }).isRequired, (0, _shape["default"])({
            gte: numberOrPropsFunc
        }).isRequired ];
        function argValidator(props, propName) {
            return argValidators.every((function(validator) {
                return !!validator(props, propName);
            }));
        }
        var thunkValueValidator = (0, _valuesOf["default"])(number).isRequired;
        function betweenValidator(options) {
            var argError = argValidator({
                options
            }, "options");
            if (argError) {
                throw new TypeError("between: only one of the pairs of `lt`/`lte`, and `gt`/`gte`, may be supplied, and at least one pair must be provided.");
            }
            var optsThunks = propsThunkify(options);
            var validator = function between(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                if (typeof propValue !== "number") {
                    return new RangeError("".concat(componentName, ": ").concat(propName, ' must be a number, got "').concat(_typeof(propValue), '"'));
                }
                var opts = invokeWithProps(optsThunks, props);
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                var thunkValuesError = thunkValueValidator.apply(void 0, [ _defineProperty({}, propName, opts), propName, componentName ].concat(rest));
                if (thunkValuesError) {
                    return thunkValuesError;
                }
                if (!lowerCompare(propValue, opts) || !upperCompare(propValue, opts)) {
                    return new RangeError(errorMessage(componentName, propName, opts));
                }
                return null;
            };
            validator.isRequired = function betweenRequired(props, propName, componentName) {
                var propValue = props[propName];
                if (typeof propValue !== "number") {
                    return new RangeError("".concat(componentName, ": ").concat(propName, ' must be a number, got "').concat(_typeof(propValue), '"'));
                }
                var opts = invokeWithProps(optsThunks, props);
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                var thunkValuesError = thunkValueValidator.apply(void 0, [ _defineProperty({}, propName, opts), propName, componentName ].concat(rest));
                if (thunkValuesError) {
                    return thunkValuesError;
                }
                if (!lowerCompare(propValue, opts) || !upperCompare(propValue, opts)) {
                    return new RangeError(errorMessage(componentName, propName, opts));
                }
                return null;
            };
            return (0, _wrapValidator["default"])(validator, "between", options);
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var callBind = __webpack_require__(27);
        var implementation = __webpack_require__(96);
        var getPolyfill = __webpack_require__(99);
        var shim = __webpack_require__(100);
        var polyfill = callBind(getPolyfill(), Object);
        define(polyfill, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = polyfill;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var RequireObjectCoercible = __webpack_require__(97);
        var callBound = __webpack_require__(21);
        var $isEnumerable = callBound("Object.prototype.propertyIsEnumerable");
        var $push = callBound("Array.prototype.push");
        module.exports = function entries(O) {
            var obj = RequireObjectCoercible(O);
            var entrys = [];
            for (var key in obj) {
                if ($isEnumerable(obj, key)) {
                    $push(entrys, [ key, obj[key] ]);
                }
            }
            return entrys;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        module.exports = __webpack_require__(98);
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $TypeError = GetIntrinsic("%TypeError%");
        module.exports = function CheckObjectCoercible(value, optMessage) {
            if (value == null) {
                throw new $TypeError(optMessage || "Cannot call method on " + value);
            }
            return value;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(96);
        module.exports = function getPolyfill() {
            return typeof Object.entries === "function" ? Object.entries : implementation;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var getPolyfill = __webpack_require__(99);
        var define = __webpack_require__(29);
        module.exports = function shimEntries() {
            var polyfill = getPolyfill();
            define(Object, {
                entries: polyfill
            }, {
                entries: function testEntries() {
                    return Object.entries !== polyfill;
                }
            });
            return polyfill;
        };
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = shapeValidator;
        var _isPlainObject = _interopRequireDefault(__webpack_require__(102));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function shapeValidator(shapeTypes) {
            if (!(0, _isPlainObject["default"])(shapeTypes)) {
                throw new TypeError("shape must be a normal object");
            }
            function shape(props, propName, componentName, location) {
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
                    rest[_key - 4] = arguments[_key];
                }
                for (var key in shapeTypes) {
                    var checker = shapeTypes[key];
                    if (checker) {
                        var error = checker.apply(void 0, [ propValue, key, componentName, location ].concat(rest));
                        if (error) {
                            return error;
                        }
                    }
                }
                return null;
            }
            shape.isRequired = function shapeRequired(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return new TypeError("".concat(componentName, ": ").concat(propName, " is required."));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return shape.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(shape, "shape", shapeTypes);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _isPlainObject = _interopRequireDefault(__webpack_require__(91));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var _default = _isPlainObject["default"];
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = valuesOfValidator;
        var _isPrimitive = _interopRequireDefault(__webpack_require__(104));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function valuesOfValidator(propType) {
            if (typeof propType !== "function") {
                throw new TypeError("objectOf: propType must be a function");
            }
            var validator = function valuesOf(props, propName, componentName, location, propFullName) {
                for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
                    rest[_key - 5] = arguments[_key];
                }
                var propValue = props[propName];
                if (propValue == null || (0, _isPrimitive["default"])(propValue)) {
                    return null;
                }
                var firstError;
                Object.keys(propValue).some((function(key) {
                    firstError = propType.apply(void 0, [ propValue, key, componentName, location, "".concat(propFullName, ".").concat(key) ].concat(rest));
                    return firstError;
                }));
                return firstError || null;
            };
            validator.isRequired = function valuesOfRequired(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return new TypeError("".concat(componentName, ": ").concat(propName, " is required."));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return validator.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, "valuesOf", propType);
        }
    }, (__unused_webpack_module, exports) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = isPrimitive;
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function _typeof(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function _typeof(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function isPrimitive(x) {
            return !x || _typeof(x) !== "object" && typeof x !== "function";
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = booleanSomeValidator;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function booleanSomeValidator() {
            for (var _len = arguments.length, notAllPropsFalse = new Array(_len), _key = 0; _key < _len; _key++) {
                notAllPropsFalse[_key] = arguments[_key];
            }
            if (notAllPropsFalse.length < 1) {
                throw new TypeError("at least one prop (one of which must be `true`) is required");
            }
            if (!notAllPropsFalse.every((function(x) {
                return typeof x === "string";
            }))) {
                throw new TypeError("all booleanSome props must be strings");
            }
            var propsList = notAllPropsFalse.join(", or ");
            var validator = function booleanSome(props, propName, componentName) {
                var countFalse = function countFalse(count, prop) {
                    return count + (props[prop] === false ? 1 : 0);
                };
                var falsePropCount = notAllPropsFalse.reduce(countFalse, 0);
                if (falsePropCount === notAllPropsFalse.length) {
                    return new Error("A ".concat(componentName, " must have at least one of these boolean props be `true`: ").concat(propsList));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return _propTypes.bool.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            validator.isRequired = function booleanSomeRequired(props, propName, componentName) {
                var countFalse = function countFalse(count, prop) {
                    return count + (props[prop] === false ? 1 : 0);
                };
                var falsePropCount = notAllPropsFalse.reduce(countFalse, 0);
                if (falsePropCount === notAllPropsFalse.length) {
                    return new Error("A ".concat(componentName, " must have at least one of these boolean props be `true`: ").concat(propsList));
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
                    rest[_key3 - 3] = arguments[_key3];
                }
                return _propTypes.bool.isRequired.apply(_propTypes.bool, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, "booleanSome: ".concat(propsList), notAllPropsFalse);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = childrenHavePropXorChildren;
        var _react = _interopRequireDefault(__webpack_require__(12));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function _typeof(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function _typeof(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function childrenHavePropXorChildren(prop) {
            if (typeof prop !== "string" && _typeof(prop) !== "symbol") {
                throw new TypeError("invalid prop: must be string or symbol");
            }
            var validator = function childrenHavePropXorChildrenWithProp(_ref, _, componentName) {
                var children = _ref.children;
                var truthyChildrenCount = 0;
                var propCount = 0;
                var grandchildrenCount = 0;
                _react["default"].Children.forEach(children, (function(child) {
                    if (!child) {
                        return;
                    }
                    truthyChildrenCount += 1;
                    if (child.props[prop]) {
                        propCount += 1;
                    }
                    if (_react["default"].Children.count(child.props.children)) {
                        grandchildrenCount += 1;
                    }
                }));
                if (propCount === truthyChildrenCount && grandchildrenCount === 0 || propCount === 0 && grandchildrenCount === truthyChildrenCount || propCount === 0 && grandchildrenCount === 0) {
                    return null;
                }
                return new TypeError("`".concat(componentName, "` requires children to all have prop “").concat(prop, "”, all have children, or all have neither."));
            };
            validator.isRequired = validator;
            return (0, _wrapValidator["default"])(validator, "childrenHavePropXorChildrenWithProp:".concat(prop), prop);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = childrenOf;
        var _renderableChildren = _interopRequireDefault(__webpack_require__(108));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }));
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function validateChildren(propType, children, props) {
            for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                rest[_key - 3] = arguments[_key];
            }
            var error;
            children.some((function(child) {
                error = propType.apply(void 0, [ _objectSpread(_objectSpread({}, props), {}, {
                    children: child
                }), "children" ].concat(rest));
                return error;
            }));
            return error || null;
        }
        function childrenOf(propType) {
            function childrenOfPropType(props, propName, componentName) {
                if (propName !== "children") {
                    return new TypeError("".concat(componentName, ' is using the childrenOf validator on non-children prop "').concat(propName, '"'));
                }
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                var children = (0, _renderableChildren["default"])(propValue);
                if (children.length === 0) {
                    return null;
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return validateChildren.apply(void 0, [ propType, children, props, componentName ].concat(rest));
            }
            childrenOfPropType.isRequired = function(props, propName, componentName) {
                if (propName !== "children") {
                    return new TypeError("".concat(componentName, ' is using the childrenOf validator on non-children prop "').concat(propName, '"'));
                }
                var children = (0, _renderableChildren["default"])(props[propName]);
                if (children.length === 0) {
                    return new TypeError("`".concat(componentName, "` requires at least one node of type ").concat(propType.typeName || propType.name));
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
                    rest[_key3 - 3] = arguments[_key3];
                }
                return validateChildren.apply(void 0, [ propType, children, props, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(childrenOfPropType, "childrenOf", propType);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = renderableChildren;
        var _react = _interopRequireDefault(__webpack_require__(12));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function renderableChildren(childrenProp) {
            return _react["default"].Children.toArray(childrenProp).filter((function(child) {
                return child === 0 || child;
            }));
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _arrayPrototype = _interopRequireDefault(__webpack_require__(110));
        var _getComponentName = _interopRequireDefault(__webpack_require__(131));
        var _renderableChildren = _interopRequireDefault(__webpack_require__(108));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function onlyTypes(types, children, componentName) {
            if (!children.every((function(child) {
                return child && (0, _arrayPrototype["default"])(types, (function(Type) {
                    return Type === "*" || child.type === Type;
                }));
            }))) {
                var typeNames = types.map(_getComponentName["default"]).join(", or ");
                return new TypeError("`".concat(componentName, "` only accepts children of type ").concat(typeNames));
            }
            return null;
        }
        function isRequired(types, children, componentName) {
            if (children.length === 0) {
                var typeNames = types.map(_getComponentName["default"]).join(", or ");
                return new TypeError("`".concat(componentName, "` requires at least one node of type ").concat(typeNames));
            }
            return null;
        }
        function childrenOfType() {
            for (var _len = arguments.length, types = new Array(_len), _key = 0; _key < _len; _key++) {
                types[_key] = arguments[_key];
            }
            if (types.length < 1) {
                throw new TypeError("childrenOfType: at least 1 type is required");
            }
            function validator(props, propName, componentName) {
                return onlyTypes(types, (0, _renderableChildren["default"])(props[propName]), componentName);
            }
            validator.isRequired = function(props, propName, componentName) {
                var children = (0, _renderableChildren["default"])(props[propName]);
                return isRequired(types, children, componentName) || onlyTypes(types, children, componentName);
            };
            return (0, _wrapValidator["default"])(validator, "childrenOfType", types);
        }
        var _default = childrenOfType;
        exports["default"] = _default;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var callBound = __webpack_require__(21);
        var RequireObjectCoercible = __webpack_require__(97);
        var implementation = __webpack_require__(111);
        var getPolyfill = __webpack_require__(128);
        var shim = __webpack_require__(129);
        var $slice = callBound("Array.prototype.slice");
        var polyfill = getPolyfill();
        var boundFindShim = function find(array, predicate) {
            RequireObjectCoercible(array);
            var args = $slice(arguments, 1);
            return polyfill.apply(array, args);
        };
        define(boundFindShim, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = boundFindShim;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var ToObject = __webpack_require__(112);
        var ToLength = __webpack_require__(113);
        var IsCallable = __webpack_require__(127);
        module.exports = function find(predicate) {
            var list = ToObject(this);
            var length = ToLength(list.length);
            if (!IsCallable(predicate)) {
                throw new TypeError("Array#find: predicate must be a function");
            }
            if (length === 0) {
                return void 0;
            }
            var thisArg;
            if (arguments.length > 0) {
                thisArg = arguments[1];
            }
            for (var i = 0, value; i < length; i++) {
                value = list[i];
                if (predicate.apply(thisArg, [ value, i, list ])) {
                    return value;
                }
            }
            return void 0;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $Object = GetIntrinsic("%Object%");
        var RequireObjectCoercible = __webpack_require__(97);
        module.exports = function ToObject(value) {
            RequireObjectCoercible(value);
            return $Object(value);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var MAX_SAFE_INTEGER = __webpack_require__(114);
        var ToIntegerOrInfinity = __webpack_require__(115);
        module.exports = function ToLength(argument) {
            var len = ToIntegerOrInfinity(argument);
            if (len <= 0) {
                return 0;
            }
            if (len > MAX_SAFE_INTEGER) {
                return MAX_SAFE_INTEGER;
            }
            return len;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $Math = GetIntrinsic("%Math%");
        var $Number = GetIntrinsic("%Number%");
        module.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var abs = __webpack_require__(116);
        var floor = __webpack_require__(117);
        var ToNumber = __webpack_require__(118);
        var $isNaN = __webpack_require__(124);
        var $isFinite = __webpack_require__(125);
        var $sign = __webpack_require__(126);
        module.exports = function ToIntegerOrInfinity(value) {
            var number = ToNumber(value);
            if ($isNaN(number) || number === 0) {
                return 0;
            }
            if (!$isFinite(number)) {
                return number;
            }
            return $sign(number) * floor(abs(number));
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $abs = GetIntrinsic("%Math.abs%");
        module.exports = function abs(x) {
            return $abs(x);
        };
    }, module => {
        "use strict";
        var $floor = Math.floor;
        module.exports = function floor(x) {
            return $floor(x);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var GetIntrinsic = __webpack_require__(22);
        var $TypeError = GetIntrinsic("%TypeError%");
        var $Number = GetIntrinsic("%Number%");
        var $RegExp = GetIntrinsic("%RegExp%");
        var $parseInteger = GetIntrinsic("%parseInt%");
        var callBound = __webpack_require__(21);
        var regexTester = __webpack_require__(119);
        var isPrimitive = __webpack_require__(120);
        var $strSlice = callBound("String.prototype.slice");
        var isBinary = regexTester(/^0b[01]+$/i);
        var isOctal = regexTester(/^0o[0-7]+$/i);
        var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
        var nonWS = [ "", "​", "" ].join("");
        var nonWSregex = new $RegExp("[" + nonWS + "]", "g");
        var hasNonWS = regexTester(nonWSregex);
        var ws = [ "\t\n\v\f\r   ᠎    ", "         　\u2028", "\u2029\ufeff" ].join("");
        var trimRegex = new RegExp("(^[" + ws + "]+)|([" + ws + "]+$)", "g");
        var $replace = callBound("String.prototype.replace");
        var $trim = function(value) {
            return $replace(value, trimRegex, "");
        };
        var ToPrimitive = __webpack_require__(121);
        module.exports = function ToNumber(argument) {
            var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
            if (typeof value === "symbol") {
                throw new $TypeError("Cannot convert a Symbol value to a number");
            }
            if (typeof value === "bigint") {
                throw new $TypeError("Conversion from 'BigInt' to 'number' is not allowed.");
            }
            if (typeof value === "string") {
                if (isBinary(value)) {
                    return ToNumber($parseInteger($strSlice(value, 2), 2));
                } else if (isOctal(value)) {
                    return ToNumber($parseInteger($strSlice(value, 2), 8));
                } else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
                    return NaN;
                }
                var trimmed = $trim(value);
                if (trimmed !== value) {
                    return ToNumber(trimmed);
                }
            }
            return $Number(value);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var callBound = __webpack_require__(21);
        var $exec = callBound("RegExp.prototype.exec");
        module.exports = function regexTester(regex) {
            return function test(s) {
                return $exec(regex, s) !== null;
            };
        };
    }, module => {
        "use strict";
        module.exports = function isPrimitive(value) {
            return value === null || typeof value !== "function" && typeof value !== "object";
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var toPrimitive = __webpack_require__(122);
        module.exports = function ToPrimitive(input) {
            if (arguments.length > 1) {
                return toPrimitive(input, arguments[1]);
            }
            return toPrimitive(input);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var hasSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "symbol";
        var isPrimitive = __webpack_require__(123);
        var isCallable = __webpack_require__(62);
        var isDate = __webpack_require__(41);
        var isSymbol = __webpack_require__(46);
        var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
            if (typeof O === "undefined" || O === null) {
                throw new TypeError("Cannot call method on " + O);
            }
            if (typeof hint !== "string" || hint !== "number" && hint !== "string") {
                throw new TypeError('hint must be "string" or "number"');
            }
            var methodNames = hint === "string" ? [ "toString", "valueOf" ] : [ "valueOf", "toString" ];
            var method, result, i;
            for (i = 0; i < methodNames.length; ++i) {
                method = O[methodNames[i]];
                if (isCallable(method)) {
                    result = method.call(O);
                    if (isPrimitive(result)) {
                        return result;
                    }
                }
            }
            throw new TypeError("No default value");
        };
        var GetMethod = function GetMethod(O, P) {
            var func = O[P];
            if (func !== null && typeof func !== "undefined") {
                if (!isCallable(func)) {
                    throw new TypeError(func + " returned for property " + P + " of object " + O + " is not a function");
                }
                return func;
            }
            return void 0;
        };
        module.exports = function ToPrimitive(input) {
            if (isPrimitive(input)) {
                return input;
            }
            var hint = "default";
            if (arguments.length > 1) {
                if (arguments[1] === String) {
                    hint = "string";
                } else if (arguments[1] === Number) {
                    hint = "number";
                }
            }
            var exoticToPrim;
            if (hasSymbols) {
                if (Symbol.toPrimitive) {
                    exoticToPrim = GetMethod(input, Symbol.toPrimitive);
                } else if (isSymbol(input)) {
                    exoticToPrim = Symbol.prototype.valueOf;
                }
            }
            if (typeof exoticToPrim !== "undefined") {
                var result = exoticToPrim.call(input, hint);
                if (isPrimitive(result)) {
                    return result;
                }
                throw new TypeError("unable to convert exotic object to primitive");
            }
            if (hint === "default" && (isDate(input) || isSymbol(input))) {
                hint = "string";
            }
            return ordinaryToPrimitive(input, hint === "default" ? "number" : hint);
        };
    }, module => {
        "use strict";
        module.exports = function isPrimitive(value) {
            return value === null || typeof value !== "function" && typeof value !== "object";
        };
    }, module => {
        "use strict";
        module.exports = Number.isNaN || function isNaN(a) {
            return a !== a;
        };
    }, module => {
        "use strict";
        var $isNaN = Number.isNaN || function(a) {
            return a !== a;
        };
        module.exports = Number.isFinite || function(x) {
            return typeof x === "number" && !$isNaN(x) && x !== Infinity && x !== -Infinity;
        };
    }, module => {
        "use strict";
        module.exports = function sign(number) {
            return number >= 0 ? 1 : -1;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        module.exports = __webpack_require__(62);
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        module.exports = function getPolyfill() {
            var implemented = Array.prototype.find && [ , 1 ].find((function() {
                return true;
            })) !== 1;
            return implemented ? Array.prototype.find : __webpack_require__(111);
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var shimUnscopables = __webpack_require__(130);
        var getPolyfill = __webpack_require__(128);
        module.exports = function shimArrayPrototypeFind() {
            var polyfill = getPolyfill();
            define(Array.prototype, {
                find: polyfill
            }, {
                find: function() {
                    return Array.prototype.find !== polyfill;
                }
            });
            shimUnscopables("find");
            return polyfill;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var has = __webpack_require__(26);
        var hasUnscopables = typeof Symbol === "function" && typeof Symbol.unscopables === "symbol";
        var map = hasUnscopables && Array.prototype[Symbol.unscopables];
        var $TypeError = TypeError;
        module.exports = function shimUnscopables(method) {
            if (typeof method !== "string" || !method) {
                throw new $TypeError("method must be a non-empty string");
            }
            if (!has(Array.prototype, method)) {
                throw new $TypeError("method must be on Array.prototype");
            }
            if (hasUnscopables) {
                map[method] = true;
            }
        };
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = getComponentName;
        var _functionPrototype = _interopRequireDefault(__webpack_require__(132));
        var _reactIs = __webpack_require__(82);
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function getComponentName(Component) {
            if (typeof Component === "string") {
                return Component;
            }
            if (typeof Component === "function") {
                return Component.displayName || (0, _functionPrototype["default"])(Component);
            }
            if ((0, _reactIs.isForwardRef)({
                type: Component,
                $$typeof: _reactIs.Element
            })) {
                return Component.displayName;
            }
            if ((0, _reactIs.isMemo)(Component)) {
                return getComponentName(Component.type);
            }
            return null;
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var callBind = __webpack_require__(27);
        var implementation = __webpack_require__(133);
        var getPolyfill = __webpack_require__(134);
        var shim = __webpack_require__(135);
        var bound = callBind(implementation);
        define(bound, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = bound;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var IsCallable = __webpack_require__(127);
        var functionsHaveNames = __webpack_require__(37)();
        var callBound = __webpack_require__(21);
        var $functionToString = callBound("Function.prototype.toString");
        var $stringMatch = callBound("String.prototype.match");
        var classRegex = /^class /;
        var isClass = function isClassConstructor(fn) {
            if (IsCallable(fn)) {
                return false;
            }
            if (typeof fn !== "function") {
                return false;
            }
            try {
                var match = $stringMatch($functionToString(fn), classRegex);
                return !!match;
            } catch (e) {}
            return false;
        };
        var regex = /\s*function\s+([^(\s]*)\s*/;
        var functionProto = Function.prototype;
        module.exports = function getName() {
            if (!isClass(this) && !IsCallable(this)) {
                throw new TypeError("Function.prototype.name sham getter called on non-function");
            }
            if (functionsHaveNames) {
                return this.name;
            }
            if (this === functionProto) {
                return "";
            }
            var str = $functionToString(this);
            var match = $stringMatch(str, regex);
            var name = match && match[1];
            return name;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(133);
        module.exports = function getPolyfill() {
            return implementation;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var supportsDescriptors = __webpack_require__(29).supportsDescriptors;
        var functionsHaveNames = __webpack_require__(37)();
        var getPolyfill = __webpack_require__(134);
        var defineProperty = Object.defineProperty;
        var TypeErr = TypeError;
        module.exports = function shimName() {
            var polyfill = getPolyfill();
            if (functionsHaveNames) {
                return polyfill;
            }
            if (!supportsDescriptors) {
                throw new TypeErr("Shimming Function.prototype.name support requires ES5 property descriptor support.");
            }
            var functionProto = Function.prototype;
            defineProperty(functionProto, "name", {
                configurable: true,
                enumerable: false,
                get: function() {
                    var name = polyfill.call(this);
                    if (this !== functionProto) {
                        defineProperty(this, "name", {
                            configurable: true,
                            enumerable: false,
                            value: name,
                            writable: false
                        });
                    }
                    return name;
                }
            });
            return polyfill;
        };
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = childrenSequenceOfValidator;
        var _sequenceOf = _interopRequireDefault(__webpack_require__(137));
        var _renderableChildren = _interopRequireDefault(__webpack_require__(108));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }));
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function childrenSequenceOfValidator() {
            for (var _len = arguments.length, specifiers = new Array(_len), _key = 0; _key < _len; _key++) {
                specifiers[_key] = arguments[_key];
            }
            var seq = _sequenceOf["default"].apply(void 0, specifiers);
            var validator = function childrenSequenceOf(props, propName, componentName) {
                if (propName !== "children") {
                    return new TypeError("".concat(componentName, ' is using the childrenSequenceOf validator on non-children prop "').concat(propName, '"'));
                }
                var propValue = props[propName];
                var children = (0, _renderableChildren["default"])(propValue);
                if (children.length === 0) {
                    return null;
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return seq.apply(void 0, [ _objectSpread(_objectSpread({}, props), {}, {
                    children
                }), propName, componentName ].concat(rest));
            };
            validator.isRequired = function childrenSequenceOfRequired(props, propName, componentName) {
                if (propName !== "children") {
                    return new TypeError("".concat(componentName, ' is using the childrenSequenceOf validator on non-children prop "').concat(propName, '"'));
                }
                var propValue = props[propName];
                var children = (0, _renderableChildren["default"])(propValue);
                if (children.length === 0) {
                    return new TypeError("".concat(componentName, ": renderable children are required."));
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
                    rest[_key3 - 3] = arguments[_key3];
                }
                return seq.isRequired.apply(seq, [ _objectSpread(_objectSpread({}, props), {}, {
                    children
                }), propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, "childrenSequenceOf", specifiers);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = sequenceOfValidator;
        var _propTypes = __webpack_require__(81);
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _between = _interopRequireDefault(__webpack_require__(94));
        var _nonNegativeInteger = _interopRequireDefault(__webpack_require__(138));
        var _object = _interopRequireDefault(__webpack_require__(142));
        var _withShape = _interopRequireDefault(__webpack_require__(144));
        var _typeOf = _interopRequireDefault(__webpack_require__(143));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }));
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var minValidator = _nonNegativeInteger["default"];
        var maxValidator = (0, _and["default"])([ _nonNegativeInteger["default"], (0, _between["default"])({
            gte: 1
        }) ]);
        function validateRange(min, max) {
            if (typeof max !== "number" || typeof min !== "number") {
                return null;
            }
            if (min <= max) {
                return null;
            }
            return new RangeError("min must be less than or equal to max");
        }
        var specifierShape = {
            validator: function validator(props, propName) {
                var propValue = props[propName];
                if (typeof propValue !== "function") {
                    return new TypeError('"validator" must be a propType validator function');
                }
                return null;
            },
            min: function min(props, propName) {
                return minValidator(props, propName) || validateRange(props.min, props.max);
            },
            max: function max(props, propName) {
                return maxValidator(props, propName) || validateRange(props.min, props.max);
            }
        };
        function getMinMax(_ref) {
            var min = _ref.min, max = _ref.max;
            var minimum;
            var maximum;
            if (typeof min !== "number" && typeof max !== "number") {
                minimum = 1;
                maximum = 1;
            } else {
                minimum = typeof min === "number" ? min : 1;
                maximum = typeof max === "number" ? max : Infinity;
            }
            return {
                minimum,
                maximum
            };
        }
        function chunkByType(items) {
            var chunk = [];
            var lastType;
            return items.reduce((function(chunks, item) {
                var itemType = (0, _typeOf["default"])(item);
                if (!lastType || itemType === lastType) {
                    chunk.push(item);
                } else {
                    chunks.push(chunk);
                    chunk = [ item ];
                }
                lastType = itemType;
                return chunks;
            }), []).concat(chunk.length > 0 ? [ chunk ] : []);
        }
        function validateChunks(specifiers, props, propName, componentName) {
            var items = props[propName];
            var chunks = chunkByType(items);
            for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
                rest[_key - 4] = arguments[_key];
            }
            for (var i = 0; i < specifiers.length; i += 1) {
                var _specifiers$i = specifiers[i], validator = _specifiers$i.validator, min = _specifiers$i.min, max = _specifiers$i.max;
                var _getMinMax = getMinMax({
                    min,
                    max
                }), minimum = _getMinMax.minimum, maximum = _getMinMax.maximum;
                if (chunks.length === 0 && minimum === 0) {
                    continue;
                }
                var arrayOfValidator = (0, _propTypes.arrayOf)(validator).isRequired;
                var chunk = chunks.shift();
                var chunkError = arrayOfValidator.apply(void 0, [ _objectSpread(_objectSpread({}, props), {}, _defineProperty({}, propName, chunk)), propName, componentName ].concat(rest));
                if (chunkError) {
                    if (minimum === 0) {
                        chunks.unshift(chunk);
                        continue;
                    }
                    return chunkError;
                }
                if (chunk.length < minimum) {
                    return new RangeError("".concat(componentName, ": specifier index ").concat(i, " requires a minimum of ").concat(min, " items, but only has ").concat(chunk.length, "."));
                }
                if (chunk.length > maximum) {
                    return new RangeError("".concat(componentName, ": specifier index ").concat(i, " requires a maximum of ").concat(max, " items, but has ").concat(chunk.length, "."));
                }
            }
            if (chunks.length > 0) {
                return new TypeError("".concat(componentName, ": after all ").concat(specifiers.length, " specifiers matched, ").concat(chunks.length, " types of items were remaining."));
            }
            return null;
        }
        var specifierValidator = (0, _withShape["default"])((0, _object["default"])(), specifierShape).isRequired;
        function sequenceOfValidator() {
            for (var _len2 = arguments.length, specifiers = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                specifiers[_key2] = arguments[_key2];
            }
            if (specifiers.length === 0) {
                throw new RangeError("sequenceOf: at least one specifier is required");
            }
            var errors = specifiers.map((function(specifier, i) {
                return specifierValidator({
                    specifier
                }, "specifier", "sequenceOf specifier", "suequenceOf specifier, index ".concat(i), "specifier, index ".concat(i));
            }));
            if (errors.some(Boolean)) {
                throw new TypeError("\n      sequenceOf: all specifiers must match the appropriate shape.\n\n      Errors:\n        ".concat(errors.map((function(e, i) {
                    return " - Argument index ".concat(i, ": ").concat(e.message);
                })).join(",\n        "), "\n    "));
            }
            var validator = function sequenceOf(props, propName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
                    rest[_key3 - 2] = arguments[_key3];
                }
                var error = _propTypes.array.apply(void 0, [ props, propName ].concat(rest));
                if (error) {
                    return error;
                }
                return validateChunks.apply(void 0, [ specifiers, props, propName ].concat(rest));
            };
            validator.isRequired = function sequenceOfRequired(props, propName, componentName) {
                for (var _len4 = arguments.length, rest = new Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) {
                    rest[_key4 - 3] = arguments[_key4];
                }
                var error = _propTypes.array.isRequired.apply(_propTypes.array, [ props, propName, componentName ].concat(rest));
                if (error) {
                    return error;
                }
                return validateChunks.apply(void 0, [ specifiers, props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, "sequenceOf", specifiers);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _integer = _interopRequireDefault(__webpack_require__(139));
        var _nonNegativeNumber = _interopRequireDefault(__webpack_require__(141));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var _default = (0, _and["default"])([ (0, _integer["default"])(), (0, _nonNegativeNumber["default"])() ], "nonNegativeInteger");
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _isInteger = _interopRequireDefault(__webpack_require__(140));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function requiredInteger(props, propName, componentName) {
            var propValue = props[propName];
            if (propValue == null || !(0, _isInteger["default"])(propValue)) {
                return new RangeError("".concat(propName, " in ").concat(componentName, " must be an integer"));
            }
            return null;
        }
        var validator = function integer(props, propName) {
            var propValue = props[propName];
            if (propValue == null) {
                return null;
            }
            for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
                rest[_key - 2] = arguments[_key];
            }
            return requiredInteger.apply(void 0, [ props, propName ].concat(rest));
        };
        validator.isRequired = requiredInteger;
        var _default = function _default() {
            return (0, _wrapValidator["default"])(validator, "integer");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var floor = Math.floor;
        var finite = isFinite;
        var _default = Number.isInteger || function(x) {
            return typeof x === "number" && finite(x) && floor(x) === x;
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _objectIs = _interopRequireDefault(__webpack_require__(28));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function isNonNegative(x) {
            return typeof x === "number" && isFinite(x) && x >= 0 && !(0, _objectIs["default"])(x, -0);
        }
        function nonNegativeNumber(props, propName, componentName) {
            var value = props[propName];
            if (value == null || isNonNegative(value)) {
                return null;
            }
            return new RangeError("".concat(propName, " in ").concat(componentName, " must be a non-negative number"));
        }
        function requiredNonNegativeNumber(props, propName, componentName) {
            var value = props[propName];
            if (isNonNegative(value)) {
                return null;
            }
            return new RangeError("".concat(propName, " in ").concat(componentName, " must be a non-negative number"));
        }
        nonNegativeNumber.isRequired = requiredNonNegativeNumber;
        var _default = function _default() {
            return (0, _wrapValidator["default"])(nonNegativeNumber, "nonNegativeNumber");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _isPlainObject = _interopRequireDefault(__webpack_require__(102));
        var _typeOf = _interopRequireDefault(__webpack_require__(143));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var ReactPropTypeLocationNames = {
            prop: "prop",
            context: "context",
            childContext: "child context"
        };
        function object(props, propName, componentName, location, propFullName) {
            var propValue = props[propName];
            if (propValue == null) {
                return null;
            }
            if ((0, _isPlainObject["default"])(propValue)) {
                return null;
            }
            var locationName = ReactPropTypeLocationNames[location] || location;
            return new TypeError("Invalid ".concat(locationName, " `").concat(propFullName, "` of type `").concat((0, 
            _typeOf["default"])(propValue), "` supplied to `").concat(componentName, "`, expected `object`."));
        }
        object.isRequired = function objectRequired(props, propName, componentName, location, propFullName) {
            var propValue = props[propName];
            if (propValue == null) {
                var locationName = ReactPropTypeLocationNames[location] || location;
                return new TypeError("The ".concat(locationName, " `").concat(propFullName, "` is marked as required in `").concat(componentName, "`, but its value is `").concat(propValue, "`."));
            }
            for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
                rest[_key - 5] = arguments[_key];
            }
            return object.apply(void 0, [ props, propName, componentName, location, propFullName ].concat(rest));
        };
        var _default = function _default() {
            return (0, _wrapValidator["default"])(object, "object");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = typeOf;
        var _react = _interopRequireDefault(__webpack_require__(12));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function _typeof(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function _typeof(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function typeOf(child) {
            if (child === null) {
                return "null";
            }
            if (Array.isArray(child)) {
                return "array";
            }
            if (_typeof(child) !== "object") {
                return _typeof(child);
            }
            if (_react["default"].isValidElement(child)) {
                return child.type;
            }
            return child;
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = withShape;
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _shape = _interopRequireDefault(__webpack_require__(101));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function withShape(type, shapeTypes) {
            if (typeof type !== "function") {
                throw new TypeError("type must be a valid PropType");
            }
            var shapeValidator = (0, _shape["default"])(shapeTypes);
            return (0, _and["default"])([ type, shapeValidator ], "withShape");
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = componentWithName;
        var _react = _interopRequireDefault(__webpack_require__(12));
        var _isRegex = _interopRequireDefault(__webpack_require__(34));
        var _arrayPrototype = _interopRequireDefault(__webpack_require__(110));
        var _getComponentName = _interopRequireDefault(__webpack_require__(131));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function stripHOCs(fullName, namesOfHOCsToStrip) {
            var innerName = fullName;
            while (/\([^()]*\)/g.test(innerName)) {
                var HOC = innerName;
                var previousHOC = void 0;
                do {
                    previousHOC = HOC;
                    HOC = previousHOC.replace(/\([^()]*\)/g, "");
                } while (previousHOC !== HOC);
                if (namesOfHOCsToStrip.indexOf(HOC) === -1) {
                    return innerName;
                }
                innerName = innerName.replace(RegExp("^".concat(HOC, "\\(|\\)$"), "g"), "");
            }
            return innerName;
        }
        function hasName(name, namesOfHOCsToStrip, propValue, propName, componentName) {
            for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
                rest[_key - 5] = arguments[_key];
            }
            if (Array.isArray(propValue)) {
                return (0, _arrayPrototype["default"])(propValue.map((function(item) {
                    return hasName.apply(void 0, [ name, namesOfHOCsToStrip, item, propName, componentName ].concat(rest));
                })), Boolean) || null;
            }
            if (!_react["default"].isValidElement(propValue)) {
                return new TypeError("".concat(componentName, ".").concat(propName, " is not a valid React element"));
            }
            var type = propValue.type;
            var componentNameFromType = (0, _getComponentName["default"])(type);
            var innerComponentName = namesOfHOCsToStrip.length > 0 ? stripHOCs(componentNameFromType, namesOfHOCsToStrip) : componentNameFromType;
            if ((0, _isRegex["default"])(name) && !name.test(innerComponentName)) {
                return new TypeError("`".concat(componentName, ".").concat(propName, "` only accepts components matching the regular expression ").concat(name));
            }
            if (!(0, _isRegex["default"])(name) && innerComponentName !== name) {
                return new TypeError("`".concat(componentName, ".").concat(propName, "` only accepts components named ").concat(name, ", got ").concat(innerComponentName));
            }
            return null;
        }
        function componentWithName(name) {
            var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
            if (typeof name !== "string" && !(0, _isRegex["default"])(name)) {
                throw new TypeError("name must be a string or a regex");
            }
            var passedOptions = Object.keys(options);
            if (passedOptions.length > 1 || passedOptions.length === 1 && passedOptions[0] !== "stripHOCs") {
                throw new TypeError("The only options supported are: “stripHOCs”, got: “".concat(passedOptions.join("”, “"), "”"));
            }
            var _options$stripHOCs = options.stripHOCs, namesOfHOCsToStrip = _options$stripHOCs === void 0 ? [] : _options$stripHOCs;
            var allHOCNamesAreValid = namesOfHOCsToStrip.every((function(x) {
                if (typeof x !== "string" || /[()]/g.test(x)) {
                    return false;
                }
                return /^(?:[a-z][a-zA-Z0-9]+|[A-Z][a-z][a-zA-Z0-9]+)$/.test(x);
            }));
            if (!allHOCNamesAreValid) {
                throw new TypeError("every provided HOC name must be a string with no parens, and in camelCase");
            }
            function componentWithNameValidator(props, propName, componentName) {
                var propValue = props[propName];
                if (props[propName] == null) {
                    return null;
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return hasName.apply(void 0, [ name, namesOfHOCsToStrip, propValue, propName, componentName ].concat(rest));
            }
            componentWithNameValidator.isRequired = function componentWithNameRequired(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return new TypeError("`".concat(componentName, ".").concat(propName, "` requires at least one component named ").concat(name));
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
                    rest[_key3 - 3] = arguments[_key3];
                }
                return hasName.apply(void 0, [ name, namesOfHOCsToStrip, propValue, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(componentWithNameValidator, "componentWithName:".concat(name), name);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = disallowedIf;
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function disallowedIf(propType, otherPropName, otherPropType) {
            if (typeof propType !== "function" || typeof propType.isRequired !== "function") {
                throw new TypeError("a propType validator is required; propType validators must also provide `.isRequired`");
            }
            if (typeof otherPropName !== "string") {
                throw new TypeError("other prop name must be a string");
            }
            if (typeof otherPropType !== "function") {
                throw new TypeError("other prop type validator is required");
            }
            function disallowedIfRequired(props, propName, componentName) {
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                var error = propType.isRequired.apply(propType, [ props, propName, componentName ].concat(rest));
                if (error) {
                    return error;
                }
                if (props[otherPropName] == null) {
                    return null;
                }
                var otherError = otherPropType.apply(void 0, [ props, otherPropName, componentName ].concat(rest));
                if (otherError) {
                    return null;
                }
                return new Error("prop “".concat(propName, "” is disallowed when “").concat(otherPropName, "” matches the provided validator"));
            }
            var validator = function disallowedIfPropType(props, propName) {
                if (props[propName] == null) {
                    return null;
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
                    rest[_key2 - 2] = arguments[_key2];
                }
                return disallowedIfRequired.apply(void 0, [ props, propName ].concat(rest));
            };
            validator.isRequired = disallowedIfRequired;
            return (0, _wrapValidator["default"])(validator, "disallowedIf", {
                propType,
                otherPropName,
                otherPropType
            });
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = elementTypeValidator;
        var _propTypes = __webpack_require__(81);
        var _reactIs = __webpack_require__(82);
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _getComponentName = _interopRequireDefault(__webpack_require__(131));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function _typeof(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function _typeof(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function getTypeName(Type) {
            if (typeof Type === "string") {
                return Type;
            }
            var type = (0, _getComponentName["default"])(Type);
            return type || "Anonymous Component";
        }
        function validateElementType(Type, props, propName, componentName) {
            var type = props[propName].type;
            if (type === Type) {
                return null;
            }
            return new TypeError("".concat(componentName, ".").concat(propName, " must be a React element of type ").concat(getTypeName(Type)));
        }
        function elementTypeValidator(Type) {
            if (Type === "*") {
                return (0, _wrapValidator["default"])(_propTypes.element, "elementType(*)", Type);
            }
            if (!(0, _reactIs.isValidElementType)(Type)) {
                throw new TypeError('Type must be a React Component, an HTML element tag name, or "*". Got an '.concat(_typeof(Type)));
            }
            function elementType(props, propName, componentName) {
                if (props[propName] == null) {
                    return null;
                }
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                return validateElementType.apply(void 0, [ Type, props, propName, componentName ].concat(rest));
            }
            elementType.isRequired = elementType;
            var typeName = getTypeName(Type);
            var validatorName = "elementType(".concat(typeName, ")");
            return (0, _wrapValidator["default"])((0, _and["default"])([ _propTypes.element, elementType ], validatorName), validatorName, Type);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _propTypes = __webpack_require__(81);
        var _or = _interopRequireDefault(__webpack_require__(149));
        var _explicitNull = _interopRequireDefault(__webpack_require__(150));
        var _withShape = _interopRequireDefault(__webpack_require__(144));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var arrayOfValidator;
        var validator = (0, _or["default"])([ _explicitNull["default"], (0, _propTypes.oneOf)([ false, "", NaN ]), (0, 
        _withShape["default"])(_propTypes.array, {
            length: (0, _propTypes.oneOf)([ 0 ]).isRequired
        }).isRequired, function() {
            return arrayOfValidator.apply(void 0, arguments);
        } ]);
        arrayOfValidator = (0, _propTypes.arrayOf)(validator).isRequired;
        var _default = function _default() {
            return (0, _wrapValidator["default"])(validator, "empty");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = or;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        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);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        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;
        }
        function oneOfTypeValidator(validators) {
            var validator = function oneOfType(props, propName, componentName) {
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                var propValue = props[propName];
                if (typeof propValue === "undefined") {
                    return null;
                }
                var errors = validators.map((function(v) {
                    return v.apply(void 0, [ props, propName, componentName ].concat(rest));
                })).filter(Boolean);
                if (errors.length < validators.length) {
                    return null;
                }
                return new TypeError("".concat(componentName, ": invalid value supplied to ").concat(propName, "."));
            };
            validator.isRequired = function oneOfTypeRequired(props, propName, componentName) {
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                var propValue = props[propName];
                if (typeof propValue === "undefined") {
                    return new TypeError("".concat(componentName, ": missing value for required ").concat(propName, "."));
                }
                var errors = validators.map((function(v) {
                    return v.apply(void 0, [ props, propName, componentName ].concat(rest));
                })).filter(Boolean);
                if (errors.length === validators.length) {
                    return new TypeError("".concat(componentName, ": invalid value ").concat(errors, " supplied to required ").concat(propName, "."));
                }
                return null;
            };
            return (0, _wrapValidator["default"])(validator, "oneOfType", validators);
        }
        function or(validators) {
            var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "or";
            if (!Array.isArray(validators)) {
                throw new TypeError("or: 2 or more validators are required");
            }
            if (validators.length <= 1) {
                throw new RangeError("or: 2 or more validators are required");
            }
            var validator = oneOfTypeValidator([ (0, _propTypes.arrayOf)(oneOfTypeValidator(validators)) ].concat(_toConsumableArray(validators)));
            return (0, _wrapValidator["default"])(validator, name, validators);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function _typeof(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function _typeof(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function explicitNull(props, propName, componentName) {
            if (props[propName] == null) {
                return null;
            }
            return new TypeError("".concat(componentName, ": prop “").concat(propName, "” must be null or undefined; received ").concat(_typeof(props[propName])));
        }
        explicitNull.isRequired = function explicitNullRequired(props, propName, componentName) {
            if (props[propName] === null) {
                return null;
            }
            return new TypeError("".concat(componentName, ": prop “").concat(propName, "” must be null; received ").concat(_typeof(props[propName])));
        };
        var _default = function _default() {
            return (0, _wrapValidator["default"])(explicitNull, "explicitNull");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = keysOfValidator;
        var _isPrimitive = _interopRequireDefault(__webpack_require__(104));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function keysOfValidator(propType) {
            var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "keysOf";
            if (typeof propType !== "function") {
                throw new TypeError("argument to keysOf must be a valid PropType function");
            }
            var validator = function keysOf(props, propName, componentName, location, propFullName) {
                for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
                    rest[_key - 5] = arguments[_key];
                }
                var propValue = props[propName];
                if (propValue == null || (0, _isPrimitive["default"])(propValue)) {
                    return null;
                }
                var firstError = null;
                Object.keys(propValue).some((function(key) {
                    firstError = propType.apply(void 0, [ _defineProperty({}, key, key), key, componentName, location, "(".concat(propFullName, ").").concat(key) ].concat(rest));
                    return firstError != null;
                }));
                return firstError || null;
            };
            validator.isRequired = function keyedByRequired(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return new TypeError("".concat(componentName, ": ").concat(propName, " is required, but value is ").concat(propValue));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return validator.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, name, propType);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = mutuallyExclusiveOfType;
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }));
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function mutuallyExclusiveOfType(propType) {
            if (typeof propType !== "function") {
                throw new TypeError("a propType is required");
            }
            for (var _len = arguments.length, exclusiveProps = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                exclusiveProps[_key - 1] = arguments[_key];
            }
            if (exclusiveProps.length < 1) {
                throw new TypeError("at least one prop that is mutually exclusive with this propType is required");
            }
            var propList = exclusiveProps.join(", or ");
            var map = exclusiveProps.reduce((function(acc, prop) {
                return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, prop, true));
            }), {});
            var countProps = function countProps(count, prop) {
                return count + (map[prop] ? 1 : 0);
            };
            var validator = function mutuallyExclusiveProps(props, propName, componentName) {
                var exclusivePropCount = Object.keys(props).filter((function(prop) {
                    return props[prop] != null;
                })).reduce(countProps, 0);
                if (exclusivePropCount > 1) {
                    return new Error("A ".concat(componentName, " cannot have more than one of these props: ").concat(propList));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return propType.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            validator.isRequired = function mutuallyExclusivePropsRequired(props, propName, componentName) {
                var exclusivePropCount = Object.keys(props).filter((function(prop) {
                    return prop === propName || props[prop] != null;
                })).reduce(countProps, 0);
                if (exclusivePropCount > 1) {
                    return new Error("A ".concat(componentName, " cannot have more than one of these props: ").concat(propList));
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
                    rest[_key3 - 3] = arguments[_key3];
                }
                return propType.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, "mutuallyExclusiveProps:".concat(propList), exclusiveProps);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = mutuallyExclusiveTrue;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function mutuallyExclusiveTrue() {
            for (var _len = arguments.length, exclusiveProps = new Array(_len), _key = 0; _key < _len; _key++) {
                exclusiveProps[_key] = arguments[_key];
            }
            if (exclusiveProps.length < 1) {
                throw new TypeError("at least one prop that is mutually exclusive is required");
            }
            if (!exclusiveProps.every((function(x) {
                return typeof x === "string";
            }))) {
                throw new TypeError("all exclusive true props must be strings");
            }
            var propsList = exclusiveProps.join(", or ");
            var validator = function mutuallyExclusiveTrueProps(props, propName, componentName) {
                var countProps = function countProps(count, prop) {
                    return count + (props[prop] ? 1 : 0);
                };
                var exclusivePropCount = exclusiveProps.reduce(countProps, 0);
                if (exclusivePropCount > 1) {
                    return new Error("A ".concat(componentName, " cannot have more than one of these boolean props be true: ").concat(propsList));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return _propTypes.bool.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            validator.isRequired = function mutuallyExclusiveTruePropsRequired(props, propName, componentName) {
                var countProps = function countProps(count, prop) {
                    return count + (props[prop] ? 1 : 0);
                };
                var exclusivePropCount = exclusiveProps.reduce(countProps, 0);
                if (exclusivePropCount > 1) {
                    return new Error("A ".concat(componentName, " cannot have more than one of these boolean props be true: ").concat(propsList));
                }
                for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
                    rest[_key3 - 3] = arguments[_key3];
                }
                return _propTypes.bool.isRequired.apply(_propTypes.bool, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(validator, "mutuallyExclusiveTrueProps: ".concat(propsList), exclusiveProps);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = nChildren;
        var _react = _interopRequireDefault(__webpack_require__(12));
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function nChildren(n) {
            var propType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _propTypes.node;
            if (typeof n !== "number" || isNaN(n) || n < 0) {
                throw new TypeError("a non-negative number is required");
            }
            var validator = function nChildrenValidator(props, propName, componentName) {
                if (propName !== "children") {
                    return new TypeError("".concat(componentName, " is using the nChildren validator on a non-children prop"));
                }
                var children = props.children;
                var childrenCount = _react["default"].Children.count(children);
                if (childrenCount !== n) {
                    return new RangeError("".concat(componentName, " expects to receive ").concat(n, " children, but received ").concat(childrenCount, " children."));
                }
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                return propType.apply(void 0, [ props, propName, componentName ].concat(rest));
            };
            validator.isRequired = validator;
            return (0, _wrapValidator["default"])(validator, "nChildren:".concat(n), n);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var validNumericChars = /^[-+]?(?:[1-9][0-9]*(?:\.[0-9]+)?|0|0\.[0-9]+)$/;
        var validator = function numericString(props, propName, componentName) {
            if (props[propName] == null) {
                return null;
            }
            for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                rest[_key - 3] = arguments[_key];
            }
            var stringError = _propTypes.string.apply(void 0, [ props, propName, componentName ].concat(rest));
            if (stringError) {
                return stringError;
            }
            var value = props[propName];
            var passesRegex = validNumericChars.test(value);
            if (passesRegex) {
                return null;
            }
            return new TypeError("".concat(componentName, ': prop "').concat(propName, '" (value "').concat(value, '") must be a numeric string:\n    - starting with an optional + or -\n    - that does not have a leading zero\n    - with an optional decimal part (that contains only one decimal point, if present)\n    - that otherwise only contains digits (0-9)\n    - not +-NaN, or +-Infinity\n  '));
        };
        validator.isRequired = function numericStringRequired(props, propName, componentName) {
            if (props[propName] == null) {
                return new TypeError("".concat(componentName, ": ").concat(propName, " is required"));
            }
            for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                rest[_key2 - 3] = arguments[_key2];
            }
            return validator.apply(void 0, [ props, propName, componentName ].concat(rest));
        };
        var _default = function _default() {
            return (0, _wrapValidator["default"])(validator, "numericString");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = predicate;
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function predicate(fn) {
            var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
            if (typeof fn !== "function") {
                throw new TypeError("`fn` must be a function");
            }
            if (typeof message !== "string") {
                throw new TypeError("`message`, if provided, must be a string");
            }
            function requiredValidator(props, propName, componentName) {
                var result = fn(props[propName]);
                if (result) {
                    return null;
                }
                return new TypeError("`".concat(componentName, "` requires that `").concat(propName, "` pass a predicate function").concat(message ? ": ".concat(message) : "", "."));
            }
            function validator(props, propName) {
                if (props[propName] == null) {
                    return null;
                }
                for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
                    rest[_key - 2] = arguments[_key];
                }
                return requiredValidator.apply(void 0, [ props, propName ].concat(rest));
            }
            validator.isRequired = requiredValidator;
            return (0, _wrapValidator["default"])(validator, "predicate", fn);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = range;
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _between = _interopRequireDefault(__webpack_require__(94));
        var _integer = _interopRequireDefault(__webpack_require__(139));
        var _isInteger = _interopRequireDefault(__webpack_require__(140));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
        function isValidLength(x) {
            return (0, _isInteger["default"])(x) && Math.abs(x) < MAX_SAFE_INTEGER;
        }
        function range(min, max) {
            if (!isValidLength(min) || !isValidLength(max)) {
                throw new RangeError('"range" requires two integers: '.concat(min, " and ").concat(max, " given"));
            }
            if (min === max) {
                throw new RangeError("min and max must not be the same");
            }
            return (0, _wrapValidator["default"])((0, _and["default"])([ (0, _integer["default"])(), (0, 
            _between["default"])({
                gte: min,
                lt: max
            }) ], "range"), "range", {
                min,
                max
            });
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _react = __webpack_require__(12);
        var _isPlainObject = _interopRequireDefault(__webpack_require__(102));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        var isPrototypeOf = Object.prototype.isPrototypeOf;
        function isNewRef(prop) {
            if (!(0, _isPlainObject["default"])(prop)) {
                return false;
            }
            var ownProperties = Object.keys(prop);
            return ownProperties.length === 1 && ownProperties[0] === "current";
        }
        function isCallbackRef(prop) {
            return typeof prop === "function" && !isPrototypeOf.call(_react.Component, prop) && (!_react.PureComponent || !isPrototypeOf.call(_react.PureComponent, prop));
        }
        function requiredRef(props, propName, componentName) {
            var propValue = props[propName];
            if (isCallbackRef(propValue) || isNewRef(propValue)) {
                return null;
            }
            return new TypeError("".concat(propName, " in ").concat(componentName, " must be a ref"));
        }
        function ref(props, propName, componentName) {
            var propValue = props[propName];
            if (propValue == null) {
                return null;
            }
            for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                rest[_key - 3] = arguments[_key];
            }
            return requiredRef.apply(void 0, [ props, propName, componentName ].concat(rest));
        }
        ref.isRequired = requiredRef;
        var _default = function _default() {
            return (0, _wrapValidator["default"])(ref, "ref");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = getRequiredBy;
        var _objectIs = _interopRequireDefault(__webpack_require__(28));
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function getRequiredBy(requiredByPropName, propType) {
            var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
            function requiredBy(props, propName, componentName) {
                if (props[requiredByPropName]) {
                    var propValue = props[propName];
                    if ((0, _objectIs["default"])(propValue, defaultValue) || typeof propValue === "undefined") {
                        return new TypeError("".concat(componentName, ": when ").concat(requiredByPropName, " is true, prop “").concat(propName, "” must be present."));
                    }
                }
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                return propType.apply(void 0, [ props, propName, componentName ].concat(rest));
            }
            requiredBy.isRequired = function requiredByRequired(props, propName, componentName) {
                var propValue = props[propName];
                if ((0, _objectIs["default"])(propValue, defaultValue)) {
                    return new TypeError("".concat(componentName, ": prop “").concat(propName, "” must be present."));
                }
                for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                    rest[_key2 - 3] = arguments[_key2];
                }
                return propType.isRequired.apply(propType, [ props, propName, componentName ].concat(rest));
            };
            return (0, _wrapValidator["default"])(requiredBy, "requiredBy “".concat(requiredByPropName, "”"), [ requiredByPropName, defaultValue ]);
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function customMessageWrapper(messsageFunction) {
            function restrictedProp(props, propName, componentName, location) {
                if (props[propName] == null) {
                    return null;
                }
                if (messsageFunction && typeof messsageFunction === "function") {
                    for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
                        rest[_key - 4] = arguments[_key];
                    }
                    return new TypeError(messsageFunction.apply(void 0, [ props, propName, componentName, location ].concat(rest)));
                }
                return new TypeError("The ".concat(propName, " ").concat(location, " on ").concat(componentName, " is not allowed."));
            }
            restrictedProp.isRequired = restrictedProp;
            return restrictedProp;
        }
        var _default = function _default() {
            var messsageFunction = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
            return (0, _wrapValidator["default"])(customMessageWrapper(messsageFunction), "restrictedProp");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = stringEndsWithValidator;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function stringEndsWithValidator(end) {
            if (typeof end !== "string" || end.length === 0) {
                throw new TypeError("a non-empty string is required");
            }
            var validator = function stringEndsWith(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                var stringError = _propTypes.string.apply(void 0, [ props, propName, componentName ].concat(rest));
                if (stringError) {
                    return stringError;
                }
                if (!propValue.endsWith(end) || propValue.length <= end.length) {
                    return new TypeError("".concat(componentName, ": ").concat(propName, ' does not end with "').concat(end, '"'));
                }
                return null;
            };
            validator.isRequired = function requiredStringEndsWith() {
                var stringError = _propTypes.string.isRequired.apply(_propTypes.string, arguments);
                if (stringError) {
                    return stringError;
                }
                return validator.apply(void 0, arguments);
            };
            return (0, _wrapValidator["default"])(validator, "stringEndsWith: ".concat(end));
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = stringStartsWithValidator;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function stringStartsWithValidator(start) {
            if (typeof start !== "string" || start.length === 0) {
                throw new TypeError("a non-empty string is required");
            }
            var validator = function stringStartsWith(props, propName, componentName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                    rest[_key - 3] = arguments[_key];
                }
                var stringError = _propTypes.string.apply(void 0, [ props, propName, componentName ].concat(rest));
                if (stringError) {
                    return stringError;
                }
                if (!propValue.startsWith(start) || propValue.length <= start.length) {
                    return new TypeError("".concat(componentName, ": ").concat(propName, ' does not start with "').concat(start, '"'));
                }
                return null;
            };
            validator.isRequired = function requiredStringStartsWith() {
                var stringError = _propTypes.string.isRequired.apply(_propTypes.string, arguments);
                if (stringError) {
                    return stringError;
                }
                return validator.apply(void 0, arguments);
            };
            return (0, _wrapValidator["default"])(validator, "stringStartsWith: ".concat(start));
        }
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = void 0;
        var _propTypes = __webpack_require__(81);
        var _wrapValidator = _interopRequireDefault(__webpack_require__(93));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function uniqueCountWithSet(arr) {
            return new Set(arr).size;
        }
        function uniqueCountLegacy(arr) {
            var seen = [];
            arr.forEach((function(item) {
                if (seen.indexOf(item) === -1) {
                    seen.push(item);
                }
            }));
            return seen.length;
        }
        var getUniqueCount = typeof Set === "function" ? uniqueCountWithSet : uniqueCountLegacy;
        function requiredUniqueArray(props, propName, componentName) {
            for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
                rest[_key - 3] = arguments[_key];
            }
            var result = _propTypes.array.isRequired.apply(_propTypes.array, [ props, propName, componentName ].concat(rest));
            if (result != null) {
                return result;
            }
            var propValue = props[propName];
            var uniqueCount = getUniqueCount(propValue);
            if (uniqueCount !== propValue.length) {
                return new RangeError("".concat(componentName, ": values must be unique. ").concat(propValue.length - uniqueCount, " duplicate values found."));
            }
            return null;
        }
        function uniqueArray(props, propName) {
            var propValue = props[propName];
            if (propValue == null) {
                return null;
            }
            for (var _len2 = arguments.length, rest = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
                rest[_key2 - 2] = arguments[_key2];
            }
            return requiredUniqueArray.apply(void 0, [ props, propName ].concat(rest));
        }
        uniqueArray.isRequired = requiredUniqueArray;
        var _default = function _default() {
            return (0, _wrapValidator["default"])(uniqueArray, "uniqueArray");
        };
        exports["default"] = _default;
    }, (__unused_webpack_module, exports, __webpack_require__) => {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = uniqueArrayOfTypeValidator;
        var _propTypes = __webpack_require__(81);
        var _and = _interopRequireDefault(__webpack_require__(92));
        var _uniqueArray = _interopRequireDefault(__webpack_require__(163));
        function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : {
                default: obj
            };
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }));
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var unique = (0, _uniqueArray["default"])();
        function uniqueArrayOfTypeValidator(type) {
            if (typeof type !== "function") {
                throw new TypeError("type must be a validator function");
            }
            var mapper = null;
            var name = "uniqueArrayOfType";
            for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                rest[_key - 1] = arguments[_key];
            }
            if (rest.length === 1) {
                if (typeof rest[0] === "function") {
                    mapper = rest[0];
                } else if (typeof rest[0] === "string") {
                    name = rest[0];
                } else {
                    throw new TypeError("single input must either be string or function");
                }
            } else if (rest.length === 2) {
                if (typeof rest[0] === "function" && typeof rest[1] === "string") {
                    mapper = rest[0];
                    name = rest[1];
                } else {
                    throw new TypeError("multiple inputs must be in [function, string] order");
                }
            } else if (rest.length > 2) {
                throw new TypeError("only [], [name], [mapper], and [mapper, name] are valid inputs");
            }
            function uniqueArrayOfMapped(props, propName) {
                var propValue = props[propName];
                if (propValue == null) {
                    return null;
                }
                var values = propValue.map(mapper);
                for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
                    args[_key2 - 2] = arguments[_key2];
                }
                return unique.apply(void 0, [ _objectSpread(_objectSpread({}, props), {}, _defineProperty({}, propName, values)), propName ].concat(args));
            }
            uniqueArrayOfMapped.isRequired = function isRequired(props, propName) {
                var propValue = props[propName];
                for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
                    args[_key3 - 2] = arguments[_key3];
                }
                if (propValue == null) {
                    return _propTypes.array.isRequired.apply(_propTypes.array, [ props, propName ].concat(args));
                }
                return uniqueArrayOfMapped.apply(void 0, [ props, propName ].concat(args));
            };
            var arrayValidator = (0, _propTypes.arrayOf)(type);
            var uniqueValidator = mapper ? uniqueArrayOfMapped : unique;
            var validator = (0, _and["default"])([ arrayValidator, uniqueValidator ], name);
            validator.isRequired = (0, _and["default"])([ uniqueValidator.isRequired, arrayValidator.isRequired ], "".concat(name, ".isRequired"));
            return validator;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            addEventListener: () => addEventListener
        });
        var CAN_USE_DOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
        function testPassiveEventListeners() {
            if (!CAN_USE_DOM) {
                return false;
            }
            if (!window.addEventListener || !window.removeEventListener || !Object.defineProperty) {
                return false;
            }
            var supportsPassiveOption = false;
            try {
                var opts = Object.defineProperty({}, "passive", {
                    get: function() {
                        function get() {
                            supportsPassiveOption = true;
                        }
                        return get;
                    }()
                });
                var noop = function noop() {};
                window.addEventListener("testPassiveEventSupport", noop, opts);
                window.removeEventListener("testPassiveEventSupport", noop, opts);
            } catch (e) {}
            return supportsPassiveOption;
        }
        var memoized = void 0;
        function canUsePassiveEventListeners() {
            if (memoized === undefined) {
                memoized = testPassiveEventListeners();
            }
            return memoized;
        }
        function normalizeEventOptions(eventOptions) {
            if (!eventOptions) {
                return undefined;
            }
            if (!canUsePassiveEventListeners()) {
                return !!eventOptions.capture;
            }
            return eventOptions;
        }
        function eventOptionsKey(normalizedEventOptions) {
            if (!normalizedEventOptions) {
                return 0;
            }
            if (normalizedEventOptions === true) {
                return 100;
            }
            var capture = normalizedEventOptions.capture << 0;
            var passive = normalizedEventOptions.passive << 1;
            var once = normalizedEventOptions.once << 2;
            return capture + passive + once;
        }
        function ensureCanMutateNextEventHandlers(eventHandlers) {
            if (eventHandlers.handlers === eventHandlers.nextHandlers) {
                eventHandlers.nextHandlers = eventHandlers.handlers.slice();
            }
        }
        function TargetEventHandlers(target) {
            this.target = target;
            this.events = {};
        }
        TargetEventHandlers.prototype.getEventHandlers = function() {
            function getEventHandlers(eventName, options) {
                var key = String(eventName) + " " + String(eventOptionsKey(options));
                if (!this.events[key]) {
                    this.events[key] = {
                        handlers: [],
                        handleEvent: undefined
                    };
                    this.events[key].nextHandlers = this.events[key].handlers;
                }
                return this.events[key];
            }
            return getEventHandlers;
        }();
        TargetEventHandlers.prototype.handleEvent = function() {
            function handleEvent(eventName, options, event) {
                var eventHandlers = this.getEventHandlers(eventName, options);
                eventHandlers.handlers = eventHandlers.nextHandlers;
                eventHandlers.handlers.forEach((function(handler) {
                    if (handler) {
                        handler(event);
                    }
                }));
            }
            return handleEvent;
        }();
        TargetEventHandlers.prototype.add = function() {
            function add(eventName, listener, options) {
                var _this = this;
                var eventHandlers = this.getEventHandlers(eventName, options);
                ensureCanMutateNextEventHandlers(eventHandlers);
                if (eventHandlers.nextHandlers.length === 0) {
                    eventHandlers.handleEvent = this.handleEvent.bind(this, eventName, options);
                    this.target.addEventListener(eventName, eventHandlers.handleEvent, options);
                }
                eventHandlers.nextHandlers.push(listener);
                var isSubscribed = true;
                var unsubscribe = function() {
                    function unsubscribe() {
                        if (!isSubscribed) {
                            return;
                        }
                        isSubscribed = false;
                        ensureCanMutateNextEventHandlers(eventHandlers);
                        var index = eventHandlers.nextHandlers.indexOf(listener);
                        eventHandlers.nextHandlers.splice(index, 1);
                        if (eventHandlers.nextHandlers.length === 0) {
                            if (_this.target) {
                                _this.target.removeEventListener(eventName, eventHandlers.handleEvent, options);
                            }
                            eventHandlers.handleEvent = undefined;
                        }
                    }
                    return unsubscribe;
                }();
                return unsubscribe;
            }
            return add;
        }();
        var EVENT_HANDLERS_KEY = "__consolidated_events_handlers__";
        function addEventListener(target, eventName, listener, options) {
            if (!target[EVENT_HANDLERS_KEY]) {
                target[EVENT_HANDLERS_KEY] = new TargetEventHandlers(target);
            }
            var normalizedEventOptions = normalizeEventOptions(options);
            return target[EVENT_HANDLERS_KEY].add(eventName, listener, normalizedEventOptions);
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var callBind = __webpack_require__(27);
        var implementation = __webpack_require__(167);
        var getPolyfill = __webpack_require__(168);
        var shim = __webpack_require__(169);
        var polyfill = callBind(getPolyfill(), Object);
        define(polyfill, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = polyfill;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var RequireObjectCoercible = __webpack_require__(97);
        var callBound = __webpack_require__(21);
        var $isEnumerable = callBound("Object.prototype.propertyIsEnumerable");
        var $push = callBound("Array.prototype.push");
        module.exports = function values(O) {
            var obj = RequireObjectCoercible(O);
            var vals = [];
            for (var key in obj) {
                if ($isEnumerable(obj, key)) {
                    $push(vals, obj[key]);
                }
            }
            return vals;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(167);
        module.exports = function getPolyfill() {
            return typeof Object.values === "function" ? Object.values : implementation;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var getPolyfill = __webpack_require__(168);
        var define = __webpack_require__(29);
        module.exports = function shimValues() {
            var polyfill = getPolyfill();
            define(Object, {
                values: polyfill
            }, {
                values: function testValues() {
                    return Object.values !== polyfill;
                }
            });
            return polyfill;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var implementation = __webpack_require__(171);
        var getPolyfill = __webpack_require__(172);
        var polyfill = getPolyfill();
        var shim = __webpack_require__(173);
        var boundContains = function contains(node, other) {
            return polyfill.apply(node, [ other ]);
        };
        define(boundContains, {
            getPolyfill,
            implementation,
            shim
        });
        module.exports = boundContains;
    }, module => {
        "use strict";
        module.exports = function contains(other) {
            if (arguments.length < 1) {
                throw new TypeError("1 argument is required");
            }
            if (typeof other !== "object") {
                throw new TypeError("Argument 1 (”other“) to Node.contains must be an instance of Node");
            }
            var node = other;
            do {
                if (this === node) {
                    return true;
                }
                if (node) {
                    node = node.parentNode;
                }
            } while (node);
            return false;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var implementation = __webpack_require__(171);
        module.exports = function getPolyfill() {
            if (typeof document !== "undefined") {
                if (document.contains) {
                    return document.contains;
                }
                if (document.body && document.body.contains) {
                    try {
                        if (typeof document.body.contains.call(document, "") === "boolean") {
                            return document.body.contains;
                        }
                    } catch (e) {}
                }
            }
            return implementation;
        };
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        "use strict";
        var define = __webpack_require__(29);
        var getPolyfill = __webpack_require__(172);
        module.exports = function shimContains() {
            var polyfill = getPolyfill();
            if (typeof document !== "undefined") {
                define(document, {
                    contains: polyfill
                }, {
                    contains: function() {
                        return document.contains !== polyfill;
                    }
                });
                if (typeof Element !== "undefined") {
                    define(Element.prototype, {
                        contains: polyfill
                    }, {
                        contains: function() {
                            return Element.prototype.contains !== polyfill;
                        }
                    });
                }
            }
            return polyfill;
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var simple_linear_scale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(175);
        var simple_linear_scale__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(simple_linear_scale__WEBPACK_IMPORTED_MODULE_1__);
        var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4);
        var clsx__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9);
        var _components_units_list__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(78);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Slider = function(_Component) {
            _inherits(Slider, _Component);
            var _super = _createSuper(Slider);
            function Slider() {
                var _this;
                _classCallCheck(this, Slider);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    isDragging: false,
                    isUnitsListOpen: false
                });
                _defineProperty(_assertThisInitialized(_this), "el", (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRef)());
                _defineProperty(_assertThisInitialized(_this), "hasUnitsList", (function() {
                    return _this.props.options.units && _this.props.options.units.length > 1;
                }));
                _defineProperty(_assertThisInitialized(_this), "getAllowedDecimalPlaces", (function() {
                    var properUnit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
                    var decimals = _this.props.options.decimals;
                    if (_this.props.options.units) {
                        var units = _this.props.options.units.find((function(_ref) {
                            var unit = _ref.unit;
                            return unit === (properUnit || _this.getCurrentUnit());
                        }));
                        if (units) {
                            decimals = units.decimals;
                        }
                    }
                    return decimals !== 0 && !decimals ? 0 : decimals;
                }));
                _defineProperty(_assertThisInitialized(_this), "withDefault", (function(currentUnit, defaultUnit) {
                    return _this.props.options.units ? _this.props.options.units.find((function(_ref2) {
                        var unit = _ref2.unit;
                        return unit === currentUnit;
                    })) ? currentUnit : currentUnit || defaultUnit : currentUnit || defaultUnit;
                }));
                _defineProperty(_assertThisInitialized(_this), "getCurrentUnit", (function() {
                    var defaultUnit = _this.props.options.units ? _this.props.options.units[0].unit : _this.props.options.defaultUnit === false ? "" : _this.props.options.defaultUnit || "px";
                    if (_this.props.value === "NaN" || _this.props.value === "" || _this.props.value === undefined) {
                        return defaultUnit;
                    }
                    return _this.props.options.units ? _this.withDefault(_this.props.value.toString().replace(/[0-9]/g, "").replace(/\-/g, "").replace(/\./g, ""), _this.props.options.units[0].unit) : defaultUnit;
                }));
                _defineProperty(_assertThisInitialized(_this), "getMax", (function() {
                    if (_this.props.options.units) {
                        var unit = _this.props.options.units.find((function(_ref3) {
                            var unit = _ref3.unit;
                            return unit === _this.getCurrentUnit();
                        }));
                        return unit ? unit.max : 100;
                    }
                    return _this.props.options.max || 100;
                }));
                _defineProperty(_assertThisInitialized(_this), "getMin", (function() {
                    if (_this.props.options.units) {
                        var unit = _this.props.options.units.find((function(_ref4) {
                            var unit = _ref4.unit;
                            return unit === _this.getCurrentUnit();
                        }));
                        return unit ? unit.min : 0;
                    }
                    return _this.props.options.min || 0;
                }));
                _defineProperty(_assertThisInitialized(_this), "getNumericValue", (function() {
                    var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, _ref5$forPosition = _ref5.forPosition, forPosition = _ref5$forPosition === void 0 ? false : _ref5$forPosition;
                    var maybeValue = parseFloat(_this.props.value, 10);
                    if (maybeValue === 0) {
                        return maybeValue;
                    }
                    if (!maybeValue) {
                        if (_this.props.options.defaultPosition && _this.props.options.defaultPosition === "center" && forPosition) {
                            var min = parseFloat(_this.getMin(), 10);
                            var max = parseFloat(_this.getMax(), 10);
                            return (max - min) / 2 + min;
                        }
                        return "";
                    }
                    return maybeValue;
                }));
                _defineProperty(_assertThisInitialized(_this), "handleBlur", (function() {
                    if (_this.props.options["default"] === "LOTTA_CSS_SKIP_RULE") {
                        if (_this.props.value === "LOTTA_CSS_SKIP_RULE") {
                            return;
                        }
                        if (_this.getNumericValue() === "") {
                            _this.props.onChange("LOTTA_CSS_SKIP_RULE");
                            return;
                        }
                    }
                    if (_this.props.value.toString().trim() === "") {
                        _this.props.onChange("");
                        return;
                    }
                    var newValue = "".concat((0, _utils__WEBPACK_IMPORTED_MODULE_2__.clamp)(parseFloat(_this.getMin(), 10), parseFloat(_this.getMax(), 10), parseFloat(_this.getNumericValue(), 10))).concat(_this.getCurrentUnit());
                    if (String(_this.props.value) === newValue) {
                        return;
                    }
                    _this.props.onChange(newValue);
                }));
                _defineProperty(_assertThisInitialized(_this), "handleChange", (function(value) {
                    if (_this.props.options["default"] === "LOTTA_CSS_SKIP_RULE") {
                        if (value.toString().trim() === "") {
                            _this.props.onChange("LOTTA_CSS_SKIP_RULE");
                            return;
                        }
                    }
                    if (value.toString().trim() === "") {
                        _this.props.onChange("");
                        return;
                    }
                    _this.props.onChange("".concat((0, _utils__WEBPACK_IMPORTED_MODULE_2__.clampMax)(parseFloat(_this.getMax(), 10), parseFloat(value || _this.getMin()))).concat(_this.getCurrentUnit()));
                }));
                _defineProperty(_assertThisInitialized(_this), "handleMove", (function(event) {
                    if (!_this.state.isDragging) return;
                    _this.computeAndSendNewValue(event);
                }));
                _defineProperty(_assertThisInitialized(_this), "handleUp", (function() {
                    _this.setState({
                        isDragging: false
                    });
                    _this.detachEvents();
                }));
                return _this;
            }
            _createClass(Slider, [ {
                key: "computeAndSendNewValue",
                value: function computeAndSendNewValue(_ref6) {
                    var pageX = _ref6.pageX, shiftKey = _ref6.shiftKey;
                    var _this$el$current$getB = this.el.current.getBoundingClientRect(), left = _this$el$current$getB.left, width = _this$el$current$getB.width;
                    var elLeftOffset = pageX - left - pageXOffset;
                    this.props.onChange("".concat((0, _utils__WEBPACK_IMPORTED_MODULE_2__.round)(simple_linear_scale__WEBPACK_IMPORTED_MODULE_1___default()([ 0, width ], [ parseFloat(this.getMin(), 10), parseFloat(this.getMax(), 10) ], true)(document.body.classList.contains("rtl") ? width - elLeftOffset : elLeftOffset), this.getAllowedDecimalPlaces())).concat(this.getCurrentUnit()));
                }
            }, {
                key: "attachEvents",
                value: function attachEvents() {
                    document.documentElement.addEventListener("mousemove", this.handleMove, true);
                    document.documentElement.addEventListener("mouseup", this.handleUp, true);
                }
            }, {
                key: "detachEvents",
                value: function detachEvents() {
                    document.documentElement.removeEventListener("mousemove", this.handleMove, true);
                    document.documentElement.removeEventListener("mouseup", this.handleUp, true);
                }
            }, {
                key: "render",
                value: function render() {
                    var _this2 = this, _clsx;
                    var leftValue = simple_linear_scale__WEBPACK_IMPORTED_MODULE_1___default()([ parseFloat(this.getMin(), 10), parseFloat(this.getMax(), 10) ], [ 0, 100 ], false)((0, 
                    _utils__WEBPACK_IMPORTED_MODULE_2__.clamp)(parseFloat(this.getMin(), 10), parseFloat(this.getMax(), 10), parseFloat(this.getNumericValue({
                        forPosition: true
                    }), 10) === 0 ? 0 : parseFloat(this.getNumericValue({
                        forPosition: true
                    }), 10) ? parseFloat(this.getNumericValue({
                        forPosition: true
                    }), 10) : parseFloat(this.getMin(), 10)));
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                        className: "lotta-slider-wrap",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", _objectSpread(_objectSpread({
                            className: "lotta-slider",
                            onMouseDown: function onMouseDown() {
                                _this2.attachEvents();
                                _this2.setState({
                                    isDragging: true
                                });
                            },
                            onClick: function onClick(e) {
                                return _this2.computeAndSendNewValue(e);
                            },
                            ref: this.el
                        }, this.props.options.steps ? _defineProperty({}, "data-steps", "") : {}), {}, {
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                                style: {
                                    width: "".concat(leftValue, "%")
                                }
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                tabIndex: "0",
                                onKeyDown: function onKeyDown(e) {
                                    var valueForComputation = _this2.getNumericValue();
                                    var step = 1 / Math.pow(10, _this2.getAllowedDecimalPlaces());
                                    var actualStep = e.shiftKey ? step * 10 : step;
                                    if (e.keyCode === 38 || e.keyCode === 39) {
                                        e.preventDefault();
                                        _this2.props.onChange("".concat((0, _utils__WEBPACK_IMPORTED_MODULE_2__.clamp)(parseFloat(_this2.getMin(), 10), parseFloat(_this2.getMax(), 10), valueForComputation + actualStep)).concat(_this2.getCurrentUnit()));
                                    }
                                    if (e.keyCode === 40 || e.keyCode === 37) {
                                        e.preventDefault();
                                        _this2.props.onChange("".concat((0, _utils__WEBPACK_IMPORTED_MODULE_2__.clamp)(parseFloat(_this2.getMin(), 10), parseFloat(_this2.getMax(), 10), valueForComputation - actualStep)).concat(_this2.getCurrentUnit()));
                                    }
                                },
                                style: {
                                    "--position": "".concat(leftValue, "%")
                                }
                            }) ]
                        })), !this.props.options.hideInput && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_3__["default"])("lotta-slider-input", (_clsx = {}, 
                            _defineProperty(_clsx, "lotta-value-changer", true), _defineProperty(_clsx, "no-unit-list", !this.hasUnitsList()), 
                            _defineProperty(_clsx, "no-unit", !(this.hasUnitsList() || this.props.options.defaultUnit !== false)), 
                            _defineProperty(_clsx, "active", this.state.isUnitsListOpen), _clsx)),
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("input", _objectSpread(_objectSpread({
                                type: "number"
                            }, this.props.options.ref ? {
                                ref: this.props.options.ref
                            } : {}), {}, {
                                step: 1 / Math.pow(10, this.getAllowedDecimalPlaces()),
                                value: this.getNumericValue(),
                                onBlur: function onBlur() {
                                    return _this2.handleBlur();
                                },
                                onChange: function onChange(_ref8) {
                                    var value = _ref8.target.value;
                                    return _this2.handleChange(value);
                                }
                            })), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                className: "lotta-value-divider"
                            }), !this.hasUnitsList() && this.props.options.defaultUnit !== false && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                className: "lotta-current-value",
                                children: this.withDefault(this.getCurrentUnit(), this.props.options.defaultUnit || "px")
                            }), this.hasUnitsList() && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_components_units_list__WEBPACK_IMPORTED_MODULE_4__["default"], {
                                units: this.props.options.units,
                                onChange: this.props.onChange,
                                isOpen: this.state.isUnitsListOpen,
                                toggleOpen: function toggleOpen() {
                                    return _this2.setState({
                                        isUnitsListOpen: !_this2.state.isUnitsListOpen
                                    });
                                },
                                currentUnit: this.getCurrentUnit(),
                                getNumericValue: this.getNumericValue,
                                getAllowedDecimalPlaces: this.getAllowedDecimalPlaces
                            }) ]
                        }) ]
                    });
                }
            } ]);
            return Slider;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Slider;
    }, module => {
        function linearScale(domain, range, clamp) {
            return function(value) {
                if (domain[0] === domain[1] || range[0] === range[1]) {
                    return range[0];
                }
                var ratio = (range[1] - range[0]) / (domain[1] - domain[0]), result = range[0] + ratio * (value - domain[0]);
                return clamp ? Math.min(range[1], Math.max(range[0], result)) : result;
            };
        }
        module.exports = linearScale;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Toggle
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Toggle = function(_Component) {
            _inherits(Toggle, _Component);
            var _super = _createSuper(Toggle);
            function Toggle() {
                _classCallCheck(this, Toggle);
                return _super.apply(this, arguments);
            }
            _createClass(Toggle, [ {
                key: "triggerChange",
                value: function triggerChange(value) {
                    this.props.onChange(value);
                }
            }, {
                key: "render",
                value: function render() {
                    var _this = this;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("lotta-toggle", {
                            "lotta-toggle-active": this.props.value === "yes"
                        }),
                        onClick: (0, _utils__WEBPACK_IMPORTED_MODULE_2__.composeEventHandlers)((function(e) {
                            e.stopPropagation();
                            _this.triggerChange(_this.props.value === "yes" ? "no" : "yes");
                        }), this.props.onClick),
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {})
                    });
                }
            } ]);
            return Toggle;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        _defineProperty(Toggle, "renderingConfig", {
            design: "inline"
        });
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Section
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _toggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(176);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var _panel__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(178);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Section = function(_Component) {
            _inherits(Section, _Component);
            var _super = _createSuper(Section);
            function Section() {
                _classCallCheck(this, Section);
                return _super.apply(this, arguments);
            }
            _createClass(Section, [ {
                key: "render",
                value: function render() {
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("div", {
                        className: "lotta-section-container",
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                            className: "lotta-section-option",
                            children: [ this.props.options["switch"] && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_toggle__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                value: this.props.value,
                                onChange: this.props.onChange,
                                onClick: function onClick(e) {
                                    return e.stopPropagation();
                                }
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("button", {
                                type: "button"
                            }) ]
                        })
                    });
                }
            } ]);
            return Section;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        _defineProperty(Section, "disableRevert", true);
        _defineProperty(Section, "renderingConfig", {
            design: "inline"
        });
        _defineProperty(Section, "MetaWrapper", (function(_ref) {
            var getActualControl = _ref.getActualControl, id = _ref.id, value = _ref.value, options = _ref.options, settings = _ref.settings, _onChange = _ref.onChange;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_panel__WEBPACK_IMPORTED_MODULE_3__["default"], {
                id,
                listeners: _defineProperty({}, id, options),
                onChange: function onChange(panelId, settingId, val) {
                    _onChange(val, settingId);
                },
                getSettings: typeof settings === "function" ? settings : function() {
                    return settings;
                },
                children: function children(_ref3) {
                    var container = _ref3.container, open = _ref3.open;
                    return getActualControl({
                        wrapperAttr: {
                            ref: container,
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])("lotta-section", {
                                "lotta-activated": options["switch"] ? value === "yes" : true,
                                "lotta-section-margin-top": options.marginTop,
                                "lotta-section-margin-bottom": options.marginBottom
                            }),
                            onClick: function onClick() {
                                if (options["switch"] && value !== "yes") {
                                    return;
                                }
                                open(options);
                            }
                        }
                    });
                }
            });
        }));
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _panel__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(179);
        const __WEBPACK_DEFAULT_EXPORT__ = _panel__WEBPACK_IMPORTED_MODULE_0__["default"];
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Panel
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _customizer_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
        var _react_spring_web__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(180);
        var bezier_easing__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(188);
        var bezier_easing__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(bezier_easing__WEBPACK_IMPORTED_MODULE_3__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        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);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var PanelContent = function(_Component) {
            _inherits(PanelContent, _Component);
            var _super = _createSuper(PanelContent);
            function PanelContent() {
                _classCallCheck(this, PanelContent);
                return _super.apply(this, arguments);
            }
            _createClass(PanelContent, [ {
                key: "render",
                value: function render() {
                    var _this = this;
                    var _this$props = this.props, controls = _this$props.controls, getSettings = _this$props.getSettings, style = _this$props.style, titlePrefix = _this$props.titlePrefix, label = _this$props.label, onClose = _this$props.onClose, _onChange = _this$props.onChange;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)(_react_spring_web__WEBPACK_IMPORTED_MODULE_2__.animated.div, {
                        style,
                        className: "lotta-customizer-panel",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                            className: "customize-panel-actions customize-section-description-container section-meta",
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("button", {
                                onClick: function onClick(e) {
                                    e.stopPropagation();
                                    onClose();
                                },
                                type: "button",
                                className: "customize-section-back"
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("h3", {
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("span", {
                                    children: titlePrefix
                                }), label ]
                            }) ]
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("div", {
                            className: "customizer-panel-content",
                            children: (0, _customizer_index__WEBPACK_IMPORTED_MODULE_1__.buildNestedControls)({
                                settings: getSettings,
                                controls,
                                onChange: function onChange(val, id, self) {
                                    _onChange(val, id);
                                    if (!self) {
                                        _this.forceUpdate();
                                    }
                                }
                            })
                        }) ]
                    });
                }
            } ]);
            return PanelContent;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var Panel = function(_Component2) {
            _inherits(Panel, _Component2);
            var _super2 = _createSuper(Panel);
            function Panel() {
                var _this2;
                _classCallCheck(this, Panel);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this2 = _super2.call.apply(_super2, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this2), "container", (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRef)());
                _defineProperty(_assertThisInitialized(_this2), "wrapper", null);
                _defineProperty(_assertThisInitialized(_this2), "unbind", []);
                _defineProperty(_assertThisInitialized(_this2), "current", null);
                _defineProperty(_assertThisInitialized(_this2), "reactDOMRoot", null);
                _defineProperty(_assertThisInitialized(_this2), "open", (function(options) {
                    var controls = options.controls;
                    var label = options.label || (options.id || "").replace(/./, (function(s) {
                        return s.toUpperCase();
                    })).replace(/\_|\-/g, " ");
                    _this2.current = options.id || null;
                    if (wp.customize && wp.customize.previewer && _this2.props.id) {
                        wp.customize.previewer.send("lotta-panel-open", _this2.props.id);
                    }
                    if (!_this2.wrapper) {
                        _this2.wrapper = document.createElement("div");
                        _this2.wrapper.classList.add("lotta-panel-wrapper");
                    }
                    var czControls = _this2.container.current.closest('[id="customize-theme-controls"]');
                    if (!czControls) {
                        return;
                    }
                    czControls.appendChild(_this2.wrapper);
                    var section = _this2.container.current.closest(".accordion-section-content") || _this2.container.current.closest(".lotta-customizer-panel");
                    if (!section) {
                        return;
                    }
                    section.classList.add("lotta-panel-open");
                    var titlePrefix = "";
                    var h3 = section.querySelector(".customize-section-description-container h3") || section.querySelector(".customize-panel-actions h3");
                    h3 && (titlePrefix = "".concat(h3.querySelector("span").innerText, " ▸ ").concat(h3.innerText.split("\n")[h3.innerText.split("\n").length - 1]));
                    var panelContentEl = (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_react_spring_web__WEBPACK_IMPORTED_MODULE_2__.Transition, {
                        items: options,
                        from: {
                            transform: "translateX(100%)"
                        },
                        enter: {
                            transform: "translateX(0)"
                        },
                        leave: {
                            transform: "translateX(100%)"
                        },
                        config: function config(item, type) {
                            return {
                                delay: 0,
                                duration: 18,
                                easing: bezier_easing__WEBPACK_IMPORTED_MODULE_3___default()(.645, .045, .355, 1)
                            };
                        },
                        children: function children(props) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(PanelContent, {
                                id: options.id,
                                style: props,
                                controls,
                                getSettings: function getSettings() {
                                    if (_this2.props.getSettings) {
                                        return _this2.props.getSettings(options.id);
                                    }
                                    return undefined;
                                },
                                onChange: function onChange(val, id) {
                                    if (_this2.props.onChange) {
                                        _this2.props.onChange(options.id, id, val);
                                    }
                                },
                                titlePrefix,
                                label,
                                onClose: _this2.close
                            });
                        }
                    });
                    if (_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot) {
                        if (!_this2.reactDOMRoot) {
                            _this2.reactDOMRoot = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot)(_this2.wrapper);
                        }
                        _this2.reactDOMRoot.render(panelContentEl);
                    } else {
                        (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.render)(panelContentEl, _this2.wrapper);
                    }
                }));
                _defineProperty(_assertThisInitialized(_this2), "close", (function() {
                    var section = _this2.container.current.closest(".accordion-section-content") || _this2.container.current.closest(".lotta-customizer-panel");
                    section && section.classList.remove("lotta-panel-open");
                    if (!_this2.wrapper) {
                        return;
                    }
                    var innerSection = _this2.wrapper.querySelector(".lotta-customizer-panel");
                    innerSection && innerSection.classList.add("lotta-panel-close");
                    setTimeout((function() {
                        if (wp.customize && wp.customize.previewer && _this2.props.id) {
                            wp.customize.previewer.send("lotta-panel-close", _this2.props.id);
                        }
                        if (_this2.reactDOMRoot) {
                            _this2.reactDOMRoot.unmount();
                            _this2.reactDOMRoot = null;
                        } else {
                            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.unmountComponentAtNode)(_this2.wrapper);
                        }
                        _this2.wrapper.remove();
                        _this2.wrapper = null;
                    }), 180);
                }));
                return _this2;
            }
            _createClass(Panel, [ {
                key: "componentDidMount",
                value: function componentDidMount() {
                    this.unbind.push(LottaEvents.bind("lotta-expand-panel", this.shouldExpand.bind(this)));
                    this.unbind.push(LottaEvents.bind("lotta-before-expand-panel", this.shouldClose.bind(this)));
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    this.unbind.forEach((function(cb) {
                        return cb();
                    }));
                    this.unbind = [];
                }
            }, {
                key: "shouldClose",
                value: function shouldClose(path) {
                    var listeners = Object.keys(this.props.listeners || {});
                    if (listeners.filter((function(l) {
                        return path.indexOf(l) !== -1;
                    })).length > 0) {
                        return;
                    }
                    this.close();
                }
            }, {
                key: "shouldExpand",
                value: function shouldExpand(path) {
                    if (!this.props.listeners || !this.props.listeners[path[0]]) {
                        return;
                    }
                    var active = path.shift();
                    var timeout = 0;
                    if (this.current !== active) {
                        this.open(this.props.listeners[active]);
                        timeout = 180;
                    }
                    if (path.length > 0) {
                        setTimeout((function() {
                            LottaEvents.trigger("lotta-expand-panel", path);
                        }), timeout);
                    }
                }
            }, {
                key: "render",
                value: function render() {
                    var children = this.props.children;
                    return children({
                        container: this.container,
                        open: this.open,
                        close: this.close
                    });
                }
            } ]);
            return Panel;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            a: () => animated,
            animated: () => animated
        });
        var _react_spring_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(181);
        var __WEBPACK_REEXPORT_OBJECT__ = {};
        for (const __WEBPACK_IMPORT_KEY__ in _react_spring_core__WEBPACK_IMPORTED_MODULE_0__) if ([ "default", "a", "animated" ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _react_spring_core__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__];
        __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
        var react_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(187);
        var react_dom__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react_dom__WEBPACK_IMPORTED_MODULE_1__);
        var _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(182);
        var _react_spring_animated__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(184);
        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;
        }
        const _excluded$2 = [ "style", "children", "scrollTop", "scrollLeft" ];
        const isCustomPropRE = /^--/;
        function dangerousStyleValue(name, value) {
            if (value == null || typeof value === "boolean" || value === "") return "";
            if (typeof value === "number" && value !== 0 && !isCustomPropRE.test(name) && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + "px";
            return ("" + value).trim();
        }
        const attributeCache = {};
        function applyAnimatedValues(instance, props) {
            if (!instance.nodeType || !instance.setAttribute) {
                return false;
            }
            const isFilterElement = instance.nodeName === "filter" || instance.parentNode && instance.parentNode.nodeName === "filter";
            const _ref = props, {style, children, scrollTop, scrollLeft} = _ref, attributes = _objectWithoutPropertiesLoose(_ref, _excluded$2);
            const values = Object.values(attributes);
            const names = Object.keys(attributes).map((name => isFilterElement || instance.hasAttribute(name) ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, (n => "-" + n.toLowerCase())))));
            if (children !== void 0) {
                instance.textContent = children;
            }
            for (let name in style) {
                if (style.hasOwnProperty(name)) {
                    const value = dangerousStyleValue(name, style[name]);
                    if (isCustomPropRE.test(name)) {
                        instance.style.setProperty(name, value);
                    } else {
                        instance.style[name] = value;
                    }
                }
            }
            names.forEach(((name, i) => {
                instance.setAttribute(name, values[i]);
            }));
            if (scrollTop !== void 0) {
                instance.scrollTop = scrollTop;
            }
            if (scrollLeft !== void 0) {
                instance.scrollLeft = scrollLeft;
            }
        }
        let isUnitlessNumber = {
            animationIterationCount: true,
            borderImageOutset: true,
            borderImageSlice: true,
            borderImageWidth: true,
            boxFlex: true,
            boxFlexGroup: true,
            boxOrdinalGroup: true,
            columnCount: true,
            columns: true,
            flex: true,
            flexGrow: true,
            flexPositive: true,
            flexShrink: true,
            flexNegative: true,
            flexOrder: true,
            gridRow: true,
            gridRowEnd: true,
            gridRowSpan: true,
            gridRowStart: true,
            gridColumn: true,
            gridColumnEnd: true,
            gridColumnSpan: true,
            gridColumnStart: true,
            fontWeight: true,
            lineClamp: true,
            lineHeight: true,
            opacity: true,
            order: true,
            orphans: true,
            tabSize: true,
            widows: true,
            zIndex: true,
            zoom: true,
            fillOpacity: true,
            floodOpacity: true,
            stopOpacity: true,
            strokeDasharray: true,
            strokeDashoffset: true,
            strokeMiterlimit: true,
            strokeOpacity: true,
            strokeWidth: true
        };
        const prefixKey = (prefix, key) => prefix + key.charAt(0).toUpperCase() + key.substring(1);
        const prefixes = [ "Webkit", "Ms", "Moz", "O" ];
        isUnitlessNumber = Object.keys(isUnitlessNumber).reduce(((acc, prop) => {
            prefixes.forEach((prefix => acc[prefixKey(prefix, prop)] = acc[prop]));
            return acc;
        }), isUnitlessNumber);
        const _excluded$1 = [ "x", "y", "z" ];
        const domTransforms = /^(matrix|translate|scale|rotate|skew)/;
        const pxTransforms = /^(translate)/;
        const degTransforms = /^(rotate|skew)/;
        const addUnit = (value, unit) => _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.is.num(value) && value !== 0 ? value + unit : value;
        const isValueIdentity = (value, id) => _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.is.arr(value) ? value.every((v => isValueIdentity(v, id))) : _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.is.num(value) ? value === id : parseFloat(value) === id;
        class AnimatedStyle extends _react_spring_animated__WEBPACK_IMPORTED_MODULE_3__.AnimatedObject {
            constructor(_ref) {
                let {x, y, z} = _ref, style = _objectWithoutPropertiesLoose(_ref, _excluded$1);
                const inputs = [];
                const transforms = [];
                if (x || y || z) {
                    inputs.push([ x || 0, y || 0, z || 0 ]);
                    transforms.push((xyz => [ `translate3d(${xyz.map((v => addUnit(v, "px"))).join(",")})`, isValueIdentity(xyz, 0) ]));
                }
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.eachProp)(style, ((value, key) => {
                    if (key === "transform") {
                        inputs.push([ value || "" ]);
                        transforms.push((transform => [ transform, transform === "" ]));
                    } else if (domTransforms.test(key)) {
                        delete style[key];
                        if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.is.und(value)) return;
                        const unit = pxTransforms.test(key) ? "px" : degTransforms.test(key) ? "deg" : "";
                        inputs.push((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.toArray)(value));
                        transforms.push(key === "rotate3d" ? ([x, y, z, deg]) => [ `rotate3d(${x},${y},${z},${addUnit(deg, unit)})`, isValueIdentity(deg, 0) ] : input => [ `${key}(${input.map((v => addUnit(v, unit))).join(",")})`, isValueIdentity(input, key.startsWith("scale") ? 1 : 0) ]);
                    }
                }));
                if (inputs.length) {
                    style.transform = new FluidTransform(inputs, transforms);
                }
                super(style);
            }
        }
        class FluidTransform extends _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.FluidValue {
            constructor(inputs, transforms) {
                super();
                this._value = null;
                this.inputs = inputs;
                this.transforms = transforms;
            }
            get() {
                return this._value || (this._value = this._get());
            }
            _get() {
                let transform = "";
                let identity = true;
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.each)(this.inputs, ((input, i) => {
                    const arg1 = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.getFluidValue)(input[0]);
                    const [t, id] = this.transforms[i](_react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.is.arr(arg1) ? arg1 : input.map(_react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.getFluidValue));
                    transform += " " + t;
                    identity = identity && id;
                }));
                return identity ? "none" : transform;
            }
            observerAdded(count) {
                if (count == 1) (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.each)(this.inputs, (input => (0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.each)(input, (value => (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.hasFluidValue)(value) && (0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.addFluidObserver)(value, this)))));
            }
            observerRemoved(count) {
                if (count == 0) (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.each)(this.inputs, (input => (0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.each)(input, (value => (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.hasFluidValue)(value) && (0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.removeFluidObserver)(value, this)))));
            }
            eventObserved(event) {
                if (event.type == "change") {
                    this._value = null;
                }
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.callFluidObservers)(this, event);
            }
        }
        const primitives = [ "a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "big", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "keygen", "label", "legend", "li", "link", "main", "map", "mark", "menu", "menuitem", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "section", "select", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr", "circle", "clipPath", "defs", "ellipse", "foreignObject", "g", "image", "line", "linearGradient", "mask", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "stop", "svg", "text", "tspan" ];
        const _excluded = [ "scrollTop", "scrollLeft" ];
        _react_spring_core__WEBPACK_IMPORTED_MODULE_0__.Globals.assign({
            batchedUpdates: react_dom__WEBPACK_IMPORTED_MODULE_1__.unstable_batchedUpdates,
            createStringInterpolator: _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.createStringInterpolator,
            colors: _react_spring_shared__WEBPACK_IMPORTED_MODULE_2__.colors
        });
        const host = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_3__.createHost)(primitives, {
            applyAnimatedValues,
            createAnimatedStyle: style => new AnimatedStyle(style),
            getComponentProps: _ref => {
                let props = _objectWithoutPropertiesLoose(_ref, _excluded);
                return props;
            }
        });
        const animated = host.animated;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            BailSignal: () => BailSignal,
            Controller: () => Controller,
            FrameValue: () => FrameValue,
            Globals: () => _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals,
            Interpolation: () => Interpolation,
            Spring: () => Spring,
            SpringContext: () => SpringContext,
            SpringRef: () => SpringRef,
            SpringValue: () => SpringValue,
            Trail: () => Trail,
            Transition: () => Transition,
            config: () => config,
            createInterpolator: () => _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.createInterpolator,
            easings: () => easings,
            inferTo: () => inferTo,
            interpolate: () => interpolate,
            to: () => to,
            update: () => update,
            useChain: () => useChain,
            useSpring: () => useSpring,
            useSpringRef: () => useSpringRef,
            useSprings: () => useSprings,
            useTrail: () => useTrail,
            useTransition: () => useTransition
        });
        var _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(182);
        var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
        var _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(184);
        var _react_spring_types_animated__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(185);
        var _react_spring_types_animated__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(_react_spring_types_animated__WEBPACK_IMPORTED_MODULE_3__);
        var __WEBPACK_REEXPORT_OBJECT__ = {};
        for (const __WEBPACK_IMPORT_KEY__ in _react_spring_types_animated__WEBPACK_IMPORTED_MODULE_3__) if ([ "default", "Globals", "createInterpolator", "BailSignal", "Controller", "FrameValue", "Interpolation", "Spring", "SpringContext", "SpringRef", "SpringValue", "Trail", "Transition", "config", "easings", "inferTo", "interpolate", "to", "update", "useChain", "useSpring", "useSpringRef", "useSprings", "useTrail", "useTransition" ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _react_spring_types_animated__WEBPACK_IMPORTED_MODULE_3__[__WEBPACK_IMPORT_KEY__];
        __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
        var _react_spring_types_interpolation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(186);
        var _react_spring_types_interpolation__WEBPACK_IMPORTED_MODULE_4___default = __webpack_require__.n(_react_spring_types_interpolation__WEBPACK_IMPORTED_MODULE_4__);
        var __WEBPACK_REEXPORT_OBJECT__ = {};
        for (const __WEBPACK_IMPORT_KEY__ in _react_spring_types_interpolation__WEBPACK_IMPORTED_MODULE_4__) if ([ "default", "Globals", "createInterpolator", "BailSignal", "Controller", "FrameValue", "Interpolation", "Spring", "SpringContext", "SpringRef", "SpringValue", "Trail", "Transition", "config", "easings", "inferTo", "interpolate", "to", "update", "useChain", "useSpring", "useSpringRef", "useSprings", "useTrail", "useTransition" ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _react_spring_types_interpolation__WEBPACK_IMPORTED_MODULE_4__[__WEBPACK_IMPORT_KEY__];
        __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
        function _extends() {
            _extends = Object.assign || 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);
        }
        function callProp(value, ...args) {
            return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(value) ? value(...args) : value;
        }
        const matchProp = (value, key) => value === true || !!(key && value && (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(value) ? value(key) : (0, 
        _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(value).includes(key)));
        const resolveProp = (prop, key) => _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(prop) ? key && prop[key] : prop;
        const getDefaultProp = (props, key) => props.default === true ? props[key] : props.default ? props.default[key] : undefined;
        const noopTransform = value => value;
        const getDefaultProps = (props, transform = noopTransform) => {
            let keys = DEFAULT_PROPS;
            if (props.default && props.default !== true) {
                props = props.default;
                keys = Object.keys(props);
            }
            const defaults = {};
            for (const key of keys) {
                const value = transform(props[key], key);
                if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(value)) {
                    defaults[key] = value;
                }
            }
            return defaults;
        };
        const DEFAULT_PROPS = [ "config", "onProps", "onStart", "onChange", "onPause", "onResume", "onRest" ];
        const RESERVED_PROPS = {
            config: 1,
            from: 1,
            to: 1,
            ref: 1,
            loop: 1,
            reset: 1,
            pause: 1,
            cancel: 1,
            reverse: 1,
            immediate: 1,
            default: 1,
            delay: 1,
            onProps: 1,
            onStart: 1,
            onChange: 1,
            onPause: 1,
            onResume: 1,
            onRest: 1,
            onResolve: 1,
            items: 1,
            trail: 1,
            sort: 1,
            expires: 1,
            initial: 1,
            enter: 1,
            update: 1,
            leave: 1,
            children: 1,
            onDestroyed: 1,
            keys: 1,
            callId: 1,
            parentId: 1
        };
        function getForwardProps(props) {
            const forward = {};
            let count = 0;
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(props, ((value, prop) => {
                if (!RESERVED_PROPS[prop]) {
                    forward[prop] = value;
                    count++;
                }
            }));
            if (count) {
                return forward;
            }
        }
        function inferTo(props) {
            const to = getForwardProps(props);
            if (to) {
                const out = {
                    to
                };
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(props, ((val, key) => key in to || (out[key] = val)));
                return out;
            }
            return _extends({}, props);
        }
        function computeGoal(value) {
            value = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(value);
            return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(value) ? value.map(computeGoal) : (0, 
            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isAnimatedString)(value) ? _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.createStringInterpolator({
                range: [ 0, 1 ],
                output: [ value, value ]
            })(1) : value;
        }
        function hasProps(props) {
            for (const _ in props) return true;
            return false;
        }
        function isAsyncTo(to) {
            return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(to) || _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(to) && _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(to[0]);
        }
        function detachRefs(ctrl, ref) {
            var _ctrl$ref;
            (_ctrl$ref = ctrl.ref) == null ? void 0 : _ctrl$ref.delete(ctrl);
            ref == null ? void 0 : ref.delete(ctrl);
        }
        function replaceRef(ctrl, ref) {
            if (ref && ctrl.ref !== ref) {
                var _ctrl$ref2;
                (_ctrl$ref2 = ctrl.ref) == null ? void 0 : _ctrl$ref2.delete(ctrl);
                ref.add(ctrl);
                ctrl.ref = ref;
            }
        }
        function useChain(refs, timeSteps, timeFrame = 1e3) {
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                if (timeSteps) {
                    let prevDelay = 0;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(refs, ((ref, i) => {
                        const controllers = ref.current;
                        if (controllers.length) {
                            let delay = timeFrame * timeSteps[i];
                            if (isNaN(delay)) delay = prevDelay; else prevDelay = delay;
                            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(controllers, (ctrl => {
                                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(ctrl.queue, (props => {
                                    const memoizedDelayProp = props.delay;
                                    props.delay = key => delay + callProp(memoizedDelayProp || 0, key);
                                }));
                            }));
                            ref.start();
                        }
                    }));
                } else {
                    let p = Promise.resolve();
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(refs, (ref => {
                        const controllers = ref.current;
                        if (controllers.length) {
                            const queues = controllers.map((ctrl => {
                                const q = ctrl.queue;
                                ctrl.queue = [];
                                return q;
                            }));
                            p = p.then((() => {
                                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(controllers, ((ctrl, i) => (0, 
                                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(queues[i] || [], (update => ctrl.queue.push(update)))));
                                return Promise.all(ref.start());
                            }));
                        }
                    }));
                }
            }));
        }
        const config = {
            default: {
                tension: 170,
                friction: 26
            },
            gentle: {
                tension: 120,
                friction: 14
            },
            wobbly: {
                tension: 180,
                friction: 12
            },
            stiff: {
                tension: 210,
                friction: 20
            },
            slow: {
                tension: 280,
                friction: 60
            },
            molasses: {
                tension: 280,
                friction: 120
            }
        };
        const c1 = 1.70158;
        const c2 = c1 * 1.525;
        const c3 = c1 + 1;
        const c4 = 2 * Math.PI / 3;
        const c5 = 2 * Math.PI / 4.5;
        const bounceOut = x => {
            const n1 = 7.5625;
            const d1 = 2.75;
            if (x < 1 / d1) {
                return n1 * x * x;
            } else if (x < 2 / d1) {
                return n1 * (x -= 1.5 / d1) * x + .75;
            } else if (x < 2.5 / d1) {
                return n1 * (x -= 2.25 / d1) * x + .9375;
            } else {
                return n1 * (x -= 2.625 / d1) * x + .984375;
            }
        };
        const easings = {
            linear: x => x,
            easeInQuad: x => x * x,
            easeOutQuad: x => 1 - (1 - x) * (1 - x),
            easeInOutQuad: x => x < .5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2,
            easeInCubic: x => x * x * x,
            easeOutCubic: x => 1 - Math.pow(1 - x, 3),
            easeInOutCubic: x => x < .5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2,
            easeInQuart: x => x * x * x * x,
            easeOutQuart: x => 1 - Math.pow(1 - x, 4),
            easeInOutQuart: x => x < .5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2,
            easeInQuint: x => x * x * x * x * x,
            easeOutQuint: x => 1 - Math.pow(1 - x, 5),
            easeInOutQuint: x => x < .5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2,
            easeInSine: x => 1 - Math.cos(x * Math.PI / 2),
            easeOutSine: x => Math.sin(x * Math.PI / 2),
            easeInOutSine: x => -(Math.cos(Math.PI * x) - 1) / 2,
            easeInExpo: x => x === 0 ? 0 : Math.pow(2, 10 * x - 10),
            easeOutExpo: x => x === 1 ? 1 : 1 - Math.pow(2, -10 * x),
            easeInOutExpo: x => x === 0 ? 0 : x === 1 ? 1 : x < .5 ? Math.pow(2, 20 * x - 10) / 2 : (2 - Math.pow(2, -20 * x + 10)) / 2,
            easeInCirc: x => 1 - Math.sqrt(1 - Math.pow(x, 2)),
            easeOutCirc: x => Math.sqrt(1 - Math.pow(x - 1, 2)),
            easeInOutCirc: x => x < .5 ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2,
            easeInBack: x => c3 * x * x * x - c1 * x * x,
            easeOutBack: x => 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2),
            easeInOutBack: x => x < .5 ? Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2,
            easeInElastic: x => x === 0 ? 0 : x === 1 ? 1 : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4),
            easeOutElastic: x => x === 0 ? 0 : x === 1 ? 1 : Math.pow(2, -10 * x) * Math.sin((x * 10 - .75) * c4) + 1,
            easeInOutElastic: x => x === 0 ? 0 : x === 1 ? 1 : x < .5 ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2 : Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5) / 2 + 1,
            easeInBounce: x => 1 - bounceOut(1 - x),
            easeOutBounce: bounceOut,
            easeInOutBounce: x => x < .5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2
        };
        const defaults = _extends({}, config.default, {
            mass: 1,
            damping: 1,
            easing: easings.linear,
            clamp: false
        });
        class AnimationConfig {
            constructor() {
                this.tension = void 0;
                this.friction = void 0;
                this.frequency = void 0;
                this.damping = void 0;
                this.mass = void 0;
                this.velocity = 0;
                this.restVelocity = void 0;
                this.precision = void 0;
                this.progress = void 0;
                this.duration = void 0;
                this.easing = void 0;
                this.clamp = void 0;
                this.bounce = void 0;
                this.decay = void 0;
                this.round = void 0;
                Object.assign(this, defaults);
            }
        }
        function mergeConfig(config, newConfig, defaultConfig) {
            if (defaultConfig) {
                defaultConfig = _extends({}, defaultConfig);
                sanitizeConfig(defaultConfig, newConfig);
                newConfig = _extends({}, defaultConfig, newConfig);
            }
            sanitizeConfig(config, newConfig);
            Object.assign(config, newConfig);
            for (const key in defaults) {
                if (config[key] == null) {
                    config[key] = defaults[key];
                }
            }
            let {mass, frequency, damping} = config;
            if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(frequency)) {
                if (frequency < .01) frequency = .01;
                if (damping < 0) damping = 0;
                config.tension = Math.pow(2 * Math.PI / frequency, 2) * mass;
                config.friction = 4 * Math.PI * damping * mass / frequency;
            }
            return config;
        }
        function sanitizeConfig(config, props) {
            if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.decay)) {
                config.duration = undefined;
            } else {
                const isTensionConfig = !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.tension) || !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.friction);
                if (isTensionConfig || !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.frequency) || !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.damping) || !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.mass)) {
                    config.duration = undefined;
                    config.decay = undefined;
                }
                if (isTensionConfig) {
                    config.frequency = undefined;
                }
            }
        }
        const emptyArray = [];
        class Animation {
            constructor() {
                this.changed = false;
                this.values = emptyArray;
                this.toValues = null;
                this.fromValues = emptyArray;
                this.to = void 0;
                this.from = void 0;
                this.config = new AnimationConfig;
                this.immediate = false;
            }
        }
        function scheduleProps(callId, {key, props, defaultProps, state, actions}) {
            return new Promise(((resolve, reject) => {
                var _props$cancel;
                let delay;
                let timeout;
                let cancel = matchProp((_props$cancel = props.cancel) != null ? _props$cancel : defaultProps == null ? void 0 : defaultProps.cancel, key);
                if (cancel) {
                    onStart();
                } else {
                    if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.pause)) {
                        state.paused = matchProp(props.pause, key);
                    }
                    let pause = defaultProps == null ? void 0 : defaultProps.pause;
                    if (pause !== true) {
                        pause = state.paused || matchProp(pause, key);
                    }
                    delay = callProp(props.delay || 0, key);
                    if (pause) {
                        state.resumeQueue.add(onResume);
                        actions.pause();
                    } else {
                        actions.resume();
                        onResume();
                    }
                }
                function onPause() {
                    state.resumeQueue.add(onResume);
                    state.timeouts.delete(timeout);
                    timeout.cancel();
                    delay = timeout.time - _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.now();
                }
                function onResume() {
                    if (delay > 0 && !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.skipAnimation) {
                        state.delayed = true;
                        timeout = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.setTimeout(onStart, delay);
                        state.pauseQueue.add(onPause);
                        state.timeouts.add(timeout);
                    } else {
                        onStart();
                    }
                }
                function onStart() {
                    if (state.delayed) {
                        state.delayed = false;
                    }
                    state.pauseQueue.delete(onPause);
                    state.timeouts.delete(timeout);
                    if (callId <= (state.cancelId || 0)) {
                        cancel = true;
                    }
                    try {
                        actions.start(_extends({}, props, {
                            callId,
                            cancel
                        }), resolve);
                    } catch (err) {
                        reject(err);
                    }
                }
            }));
        }
        const getCombinedResult = (target, results) => results.length == 1 ? results[0] : results.some((result => result.cancelled)) ? getCancelledResult(target.get()) : results.every((result => result.noop)) ? getNoopResult(target.get()) : getFinishedResult(target.get(), results.every((result => result.finished)));
        const getNoopResult = value => ({
            value,
            noop: true,
            finished: true,
            cancelled: false
        });
        const getFinishedResult = (value, finished, cancelled = false) => ({
            value,
            finished,
            cancelled
        });
        const getCancelledResult = value => ({
            value,
            cancelled: true,
            finished: false
        });
        function runAsync(to, props, state, target) {
            const {callId, parentId, onRest} = props;
            const {asyncTo: prevTo, promise: prevPromise} = state;
            if (!parentId && to === prevTo && !props.reset) {
                return prevPromise;
            }
            return state.promise = (async () => {
                state.asyncId = callId;
                state.asyncTo = to;
                const defaultProps = getDefaultProps(props, ((value, key) => key === "onRest" ? undefined : value));
                let preventBail;
                let bail;
                const bailPromise = new Promise(((resolve, reject) => (preventBail = resolve, bail = reject)));
                const bailIfEnded = bailSignal => {
                    const bailResult = callId <= (state.cancelId || 0) && getCancelledResult(target) || callId !== state.asyncId && getFinishedResult(target, false);
                    if (bailResult) {
                        bailSignal.result = bailResult;
                        bail(bailSignal);
                        throw bailSignal;
                    }
                };
                const animate = (arg1, arg2) => {
                    const bailSignal = new BailSignal;
                    const skipAnimationSignal = new SkipAniamtionSignal;
                    return (async () => {
                        if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.skipAnimation) {
                            stopAsync(state);
                            skipAnimationSignal.result = getFinishedResult(target, false);
                            bail(skipAnimationSignal);
                            throw skipAnimationSignal;
                        }
                        bailIfEnded(bailSignal);
                        const props = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(arg1) ? _extends({}, arg1) : _extends({}, arg2, {
                            to: arg1
                        });
                        props.parentId = callId;
                        (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(defaultProps, ((value, key) => {
                            if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props[key])) {
                                props[key] = value;
                            }
                        }));
                        const result = await target.start(props);
                        bailIfEnded(bailSignal);
                        if (state.paused) {
                            await new Promise((resume => {
                                state.resumeQueue.add(resume);
                            }));
                        }
                        return result;
                    })();
                };
                let result;
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.skipAnimation) {
                    stopAsync(state);
                    return getFinishedResult(target, false);
                }
                try {
                    let animating;
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(to)) {
                        animating = (async queue => {
                            for (const props of queue) {
                                await animate(props);
                            }
                        })(to);
                    } else {
                        animating = Promise.resolve(to(animate, target.stop.bind(target)));
                    }
                    await Promise.all([ animating.then(preventBail), bailPromise ]);
                    result = getFinishedResult(target.get(), true, false);
                } catch (err) {
                    if (err instanceof BailSignal) {
                        result = err.result;
                    } else if (err instanceof SkipAniamtionSignal) {
                        result = err.result;
                    } else {
                        throw err;
                    }
                } finally {
                    if (callId == state.asyncId) {
                        state.asyncId = parentId;
                        state.asyncTo = parentId ? prevTo : undefined;
                        state.promise = parentId ? prevPromise : undefined;
                    }
                }
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(onRest)) {
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => {
                        onRest(result, target, target.item);
                    }));
                }
                return result;
            })();
        }
        function stopAsync(state, cancelId) {
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flush)(state.timeouts, (t => t.cancel()));
            state.pauseQueue.clear();
            state.resumeQueue.clear();
            state.asyncId = state.asyncTo = state.promise = undefined;
            if (cancelId) state.cancelId = cancelId;
        }
        class BailSignal extends Error {
            constructor() {
                super("An async animation has been interrupted. You see this error because you " + "forgot to use `await` or `.catch(...)` on its returned promise.");
                this.result = void 0;
            }
        }
        class SkipAniamtionSignal extends Error {
            constructor() {
                super("SkipAnimationSignal");
                this.result = void 0;
            }
        }
        const isFrameValue = value => value instanceof FrameValue;
        let nextId$1 = 1;
        class FrameValue extends _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.FluidValue {
            constructor(...args) {
                super(...args);
                this.id = nextId$1++;
                this.key = void 0;
                this._priority = 0;
            }
            get priority() {
                return this._priority;
            }
            set priority(priority) {
                if (this._priority != priority) {
                    this._priority = priority;
                    this._onPriorityChange(priority);
                }
            }
            get() {
                const node = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this);
                return node && node.getValue();
            }
            to(...args) {
                return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.to(this, args);
            }
            interpolate(...args) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.deprecateInterpolate)();
                return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.to(this, args);
            }
            toJSON() {
                return this.get();
            }
            observerAdded(count) {
                if (count == 1) this._attach();
            }
            observerRemoved(count) {
                if (count == 0) this._detach();
            }
            _attach() {}
            _detach() {}
            _onChange(value, idle = false) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.callFluidObservers)(this, {
                    type: "change",
                    parent: this,
                    value,
                    idle
                });
            }
            _onPriorityChange(priority) {
                if (!this.idle) {
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.frameLoop.sort(this);
                }
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.callFluidObservers)(this, {
                    type: "priority",
                    parent: this,
                    priority
                });
            }
        }
        const $P = Symbol.for("SpringPhase");
        const HAS_ANIMATED = 1;
        const IS_ANIMATING = 2;
        const IS_PAUSED = 4;
        const hasAnimated = target => (target[$P] & HAS_ANIMATED) > 0;
        const isAnimating = target => (target[$P] & IS_ANIMATING) > 0;
        const isPaused = target => (target[$P] & IS_PAUSED) > 0;
        const setActiveBit = (target, active) => active ? target[$P] |= IS_ANIMATING | HAS_ANIMATED : target[$P] &= ~IS_ANIMATING;
        const setPausedBit = (target, paused) => paused ? target[$P] |= IS_PAUSED : target[$P] &= ~IS_PAUSED;
        class SpringValue extends FrameValue {
            constructor(arg1, arg2) {
                super();
                this.key = void 0;
                this.animation = new Animation;
                this.queue = void 0;
                this.defaultProps = {};
                this._state = {
                    paused: false,
                    delayed: false,
                    pauseQueue: new Set,
                    resumeQueue: new Set,
                    timeouts: new Set
                };
                this._pendingCalls = new Set;
                this._lastCallId = 0;
                this._lastToId = 0;
                this._memoizedDuration = 0;
                if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(arg1) || !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(arg2)) {
                    const props = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(arg1) ? _extends({}, arg1) : _extends({}, arg2, {
                        from: arg1
                    });
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.default)) {
                        props.default = true;
                    }
                    this.start(props);
                }
            }
            get idle() {
                return !(isAnimating(this) || this._state.asyncTo) || isPaused(this);
            }
            get goal() {
                return (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(this.animation.to);
            }
            get velocity() {
                const node = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this);
                return node instanceof _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.AnimatedValue ? node.lastVelocity || 0 : node.getPayload().map((node => node.lastVelocity || 0));
            }
            get hasAnimated() {
                return hasAnimated(this);
            }
            get isAnimating() {
                return isAnimating(this);
            }
            get isPaused() {
                return isPaused(this);
            }
            get isDelayed() {
                return this._state.delayed;
            }
            advance(dt) {
                let idle = true;
                let changed = false;
                const anim = this.animation;
                let {config, toValues} = anim;
                const payload = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getPayload)(anim.to);
                if (!payload && (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(anim.to)) {
                    toValues = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(anim.to));
                }
                anim.values.forEach(((node, i) => {
                    if (node.done) return;
                    const to = node.constructor == _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.AnimatedString ? 1 : payload ? payload[i].lastPosition : toValues[i];
                    let finished = anim.immediate;
                    let position = to;
                    if (!finished) {
                        position = node.lastPosition;
                        if (config.tension <= 0) {
                            node.done = true;
                            return;
                        }
                        let elapsed = node.elapsedTime += dt;
                        const from = anim.fromValues[i];
                        const v0 = node.v0 != null ? node.v0 : node.v0 = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(config.velocity) ? config.velocity[i] : config.velocity;
                        let velocity;
                        if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(config.duration)) {
                            let p = 1;
                            if (config.duration > 0) {
                                if (this._memoizedDuration !== config.duration) {
                                    this._memoizedDuration = config.duration;
                                    if (node.durationProgress > 0) {
                                        node.elapsedTime = config.duration * node.durationProgress;
                                        elapsed = node.elapsedTime += dt;
                                    }
                                }
                                p = (config.progress || 0) + elapsed / this._memoizedDuration;
                                p = p > 1 ? 1 : p < 0 ? 0 : p;
                                node.durationProgress = p;
                            }
                            position = from + config.easing(p) * (to - from);
                            velocity = (position - node.lastPosition) / dt;
                            finished = p == 1;
                        } else if (config.decay) {
                            const decay = config.decay === true ? .998 : config.decay;
                            const e = Math.exp(-(1 - decay) * elapsed);
                            position = from + v0 / (1 - decay) * (1 - e);
                            finished = Math.abs(node.lastPosition - position) < .1;
                            velocity = v0 * e;
                        } else {
                            velocity = node.lastVelocity == null ? v0 : node.lastVelocity;
                            const precision = config.precision || (from == to ? .005 : Math.min(1, Math.abs(to - from) * .001));
                            const restVelocity = config.restVelocity || precision / 10;
                            const bounceFactor = config.clamp ? 0 : config.bounce;
                            const canBounce = !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(bounceFactor);
                            const isGrowing = from == to ? node.v0 > 0 : from < to;
                            let isMoving;
                            let isBouncing = false;
                            const step = 1;
                            const numSteps = Math.ceil(dt / step);
                            for (let n = 0; n < numSteps; ++n) {
                                isMoving = Math.abs(velocity) > restVelocity;
                                if (!isMoving) {
                                    finished = Math.abs(to - position) <= precision;
                                    if (finished) {
                                        break;
                                    }
                                }
                                if (canBounce) {
                                    isBouncing = position == to || position > to == isGrowing;
                                    if (isBouncing) {
                                        velocity = -velocity * bounceFactor;
                                        position = to;
                                    }
                                }
                                const springForce = -config.tension * 1e-6 * (position - to);
                                const dampingForce = -config.friction * .001 * velocity;
                                const acceleration = (springForce + dampingForce) / config.mass;
                                velocity = velocity + acceleration * step;
                                position = position + velocity * step;
                            }
                        }
                        node.lastVelocity = velocity;
                        if (Number.isNaN(position)) {
                            console.warn(`Got NaN while animating:`, this);
                            finished = true;
                        }
                    }
                    if (payload && !payload[i].done) {
                        finished = false;
                    }
                    if (finished) {
                        node.done = true;
                    } else {
                        idle = false;
                    }
                    if (node.setValue(position, config.round)) {
                        changed = true;
                    }
                }));
                const node = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this);
                const currVal = node.getValue();
                if (idle) {
                    const finalVal = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(anim.to);
                    if ((currVal !== finalVal || changed) && !config.decay) {
                        node.setValue(finalVal);
                        this._onChange(finalVal);
                    } else if (changed && config.decay) {
                        this._onChange(currVal);
                    }
                    this._stop();
                } else if (changed) {
                    this._onChange(currVal);
                }
            }
            set(value) {
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => {
                    this._stop();
                    this._focus(value);
                    this._set(value);
                }));
                return this;
            }
            pause() {
                this._update({
                    pause: true
                });
            }
            resume() {
                this._update({
                    pause: false
                });
            }
            finish() {
                if (isAnimating(this)) {
                    const {to, config} = this.animation;
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => {
                        this._onStart();
                        if (!config.decay) {
                            this._set(to, false);
                        }
                        this._stop();
                    }));
                }
                return this;
            }
            update(props) {
                const queue = this.queue || (this.queue = []);
                queue.push(props);
                return this;
            }
            start(to, arg2) {
                let queue;
                if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(to)) {
                    queue = [ _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(to) ? to : _extends({}, arg2, {
                        to
                    }) ];
                } else {
                    queue = this.queue || [];
                    this.queue = [];
                }
                return Promise.all(queue.map((props => {
                    const up = this._update(props);
                    return up;
                }))).then((results => getCombinedResult(this, results)));
            }
            stop(cancel) {
                const {to} = this.animation;
                this._focus(this.get());
                stopAsync(this._state, cancel && this._lastCallId);
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => this._stop(to, cancel)));
                return this;
            }
            reset() {
                this._update({
                    reset: true
                });
            }
            eventObserved(event) {
                if (event.type == "change") {
                    this._start();
                } else if (event.type == "priority") {
                    this.priority = event.priority + 1;
                }
            }
            _prepareNode(props) {
                const key = this.key || "";
                let {to, from} = props;
                to = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(to) ? to[key] : to;
                if (to == null || isAsyncTo(to)) {
                    to = undefined;
                }
                from = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(from) ? from[key] : from;
                if (from == null) {
                    from = undefined;
                }
                const range = {
                    to,
                    from
                };
                if (!hasAnimated(this)) {
                    if (props.reverse) [to, from] = [ from, to ];
                    from = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(from);
                    if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(from)) {
                        this._set(from);
                    } else if (!(0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this)) {
                        this._set(to);
                    }
                }
                return range;
            }
            _update(_ref, isLoop) {
                let props = _extends({}, _ref);
                const {key, defaultProps} = this;
                if (props.default) Object.assign(defaultProps, getDefaultProps(props, ((value, prop) => /^on/.test(prop) ? resolveProp(value, key) : value)));
                mergeActiveFn(this, props, "onProps");
                sendEvent(this, "onProps", props, this);
                const range = this._prepareNode(props);
                if (Object.isFrozen(this)) {
                    throw Error("Cannot animate a `SpringValue` object that is frozen. " + "Did you forget to pass your component to `animated(...)` before animating its props?");
                }
                const state = this._state;
                return scheduleProps(++this._lastCallId, {
                    key,
                    props,
                    defaultProps,
                    state,
                    actions: {
                        pause: () => {
                            if (!isPaused(this)) {
                                setPausedBit(this, true);
                                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flushCalls)(state.pauseQueue);
                                sendEvent(this, "onPause", getFinishedResult(this, checkFinished(this, this.animation.to)), this);
                            }
                        },
                        resume: () => {
                            if (isPaused(this)) {
                                setPausedBit(this, false);
                                if (isAnimating(this)) {
                                    this._resume();
                                }
                                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flushCalls)(state.resumeQueue);
                                sendEvent(this, "onResume", getFinishedResult(this, checkFinished(this, this.animation.to)), this);
                            }
                        },
                        start: this._merge.bind(this, range)
                    }
                }).then((result => {
                    if (props.loop && result.finished && !(isLoop && result.noop)) {
                        const nextProps = createLoopUpdate(props);
                        if (nextProps) {
                            return this._update(nextProps, true);
                        }
                    }
                    return result;
                }));
            }
            _merge(range, props, resolve) {
                if (props.cancel) {
                    this.stop(true);
                    return resolve(getCancelledResult(this));
                }
                const hasToProp = !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(range.to);
                const hasFromProp = !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(range.from);
                if (hasToProp || hasFromProp) {
                    if (props.callId > this._lastToId) {
                        this._lastToId = props.callId;
                    } else {
                        return resolve(getCancelledResult(this));
                    }
                }
                const {key, defaultProps, animation: anim} = this;
                const {to: prevTo, from: prevFrom} = anim;
                let {to = prevTo, from = prevFrom} = range;
                if (hasFromProp && !hasToProp && (!props.default || _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(to))) {
                    to = from;
                }
                if (props.reverse) [to, from] = [ from, to ];
                const hasFromChanged = !(0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(from, prevFrom);
                if (hasFromChanged) {
                    anim.from = from;
                }
                from = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(from);
                const hasToChanged = !(0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(to, prevTo);
                if (hasToChanged) {
                    this._focus(to);
                }
                const hasAsyncTo = isAsyncTo(props.to);
                const {config} = anim;
                const {decay, velocity} = config;
                if (hasToProp || hasFromProp) {
                    config.velocity = 0;
                }
                if (props.config && !hasAsyncTo) {
                    mergeConfig(config, callProp(props.config, key), props.config !== defaultProps.config ? callProp(defaultProps.config, key) : void 0);
                }
                let node = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this);
                if (!node || _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(to)) {
                    return resolve(getFinishedResult(this, true));
                }
                const reset = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.reset) ? hasFromProp && !props.default : !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(from) && matchProp(props.reset, key);
                const value = reset ? from : this.get();
                const goal = computeGoal(to);
                const isAnimatable = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.num(goal) || _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(goal) || (0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isAnimatedString)(goal);
                const immediate = !hasAsyncTo && (!isAnimatable || matchProp(defaultProps.immediate || props.immediate, key));
                if (hasToChanged) {
                    const nodeType = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimatedType)(to);
                    if (nodeType !== node.constructor) {
                        if (immediate) {
                            node = this._set(goal);
                        } else throw Error(`Cannot animate between ${node.constructor.name} and ${nodeType.name}, as the "to" prop suggests`);
                    }
                }
                const goalType = node.constructor;
                let started = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(to);
                let finished = false;
                if (!started) {
                    const hasValueChanged = reset || !hasAnimated(this) && hasFromChanged;
                    if (hasToChanged || hasValueChanged) {
                        finished = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(computeGoal(value), goal);
                        started = !finished;
                    }
                    if (!(0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(anim.immediate, immediate) && !immediate || !(0, 
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(config.decay, decay) || !(0, 
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(config.velocity, velocity)) {
                        started = true;
                    }
                }
                if (finished && isAnimating(this)) {
                    if (anim.changed && !reset) {
                        started = true;
                    } else if (!started) {
                        this._stop(prevTo);
                    }
                }
                if (!hasAsyncTo) {
                    if (started || (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(prevTo)) {
                        anim.values = node.getPayload();
                        anim.toValues = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(to) ? null : goalType == _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.AnimatedString ? [ 1 ] : (0, 
                        _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(goal);
                    }
                    if (anim.immediate != immediate) {
                        anim.immediate = immediate;
                        if (!immediate && !reset) {
                            this._set(prevTo);
                        }
                    }
                    if (started) {
                        const {onRest} = anim;
                        (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(ACTIVE_EVENTS, (type => mergeActiveFn(this, props, type)));
                        const result = getFinishedResult(this, checkFinished(this, prevTo));
                        (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flushCalls)(this._pendingCalls, result);
                        this._pendingCalls.add(resolve);
                        if (anim.changed) _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => {
                            anim.changed = !reset;
                            onRest == null ? void 0 : onRest(result, this);
                            if (reset) {
                                callProp(defaultProps.onRest, result);
                            } else {
                                anim.onStart == null ? void 0 : anim.onStart(result, this);
                            }
                        }));
                    }
                }
                if (reset) {
                    this._set(value);
                }
                if (hasAsyncTo) {
                    resolve(runAsync(props.to, props, this._state, this));
                } else if (started) {
                    this._start();
                } else if (isAnimating(this) && !hasToChanged) {
                    this._pendingCalls.add(resolve);
                } else {
                    resolve(getNoopResult(value));
                }
            }
            _focus(value) {
                const anim = this.animation;
                if (value !== anim.to) {
                    if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidObservers)(this)) {
                        this._detach();
                    }
                    anim.to = value;
                    if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidObservers)(this)) {
                        this._attach();
                    }
                }
            }
            _attach() {
                let priority = 0;
                const {to} = this.animation;
                if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(to)) {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.addFluidObserver)(to, this);
                    if (isFrameValue(to)) {
                        priority = to.priority + 1;
                    }
                }
                this.priority = priority;
            }
            _detach() {
                const {to} = this.animation;
                if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(to)) {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.removeFluidObserver)(to, this);
                }
            }
            _set(arg, idle = true) {
                const value = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(arg);
                if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(value)) {
                    const oldNode = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this);
                    if (!oldNode || !(0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(value, oldNode.getValue())) {
                        const nodeType = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimatedType)(value);
                        if (!oldNode || oldNode.constructor != nodeType) {
                            (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.setAnimated)(this, nodeType.create(value));
                        } else {
                            oldNode.setValue(value);
                        }
                        if (oldNode) {
                            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => {
                                this._onChange(value, idle);
                            }));
                        }
                    }
                }
                return (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this);
            }
            _onStart() {
                const anim = this.animation;
                if (!anim.changed) {
                    anim.changed = true;
                    sendEvent(this, "onStart", getFinishedResult(this, checkFinished(this, anim.to)), this);
                }
            }
            _onChange(value, idle) {
                if (!idle) {
                    this._onStart();
                    callProp(this.animation.onChange, value, this);
                }
                callProp(this.defaultProps.onChange, value, this);
                super._onChange(value, idle);
            }
            _start() {
                const anim = this.animation;
                (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this).reset((0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(anim.to));
                if (!anim.immediate) {
                    anim.fromValues = anim.values.map((node => node.lastPosition));
                }
                if (!isAnimating(this)) {
                    setActiveBit(this, true);
                    if (!isPaused(this)) {
                        this._resume();
                    }
                }
            }
            _resume() {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.skipAnimation) {
                    this.finish();
                } else {
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.frameLoop.start(this);
                }
            }
            _stop(goal, cancel) {
                if (isAnimating(this)) {
                    setActiveBit(this, false);
                    const anim = this.animation;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(anim.values, (node => {
                        node.done = true;
                    }));
                    if (anim.toValues) {
                        anim.onChange = anim.onPause = anim.onResume = undefined;
                    }
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.callFluidObservers)(this, {
                        type: "idle",
                        parent: this
                    });
                    const result = cancel ? getCancelledResult(this.get()) : getFinishedResult(this.get(), checkFinished(this, goal != null ? goal : anim.to));
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flushCalls)(this._pendingCalls, result);
                    if (anim.changed) {
                        anim.changed = false;
                        sendEvent(this, "onRest", result, this);
                    }
                }
            }
        }
        function checkFinished(target, to) {
            const goal = computeGoal(to);
            const value = computeGoal(target.get());
            return (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(value, goal);
        }
        function createLoopUpdate(props, loop = props.loop, to = props.to) {
            let loopRet = callProp(loop);
            if (loopRet) {
                const overrides = loopRet !== true && inferTo(loopRet);
                const reverse = (overrides || props).reverse;
                const reset = !overrides || overrides.reset;
                return createUpdate(_extends({}, props, {
                    loop,
                    default: false,
                    pause: undefined,
                    to: !reverse || isAsyncTo(to) ? to : undefined,
                    from: reset ? props.from : undefined,
                    reset
                }, overrides));
            }
        }
        function createUpdate(props) {
            const {to, from} = props = inferTo(props);
            const keys = new Set;
            if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(to)) findDefined(to, keys);
            if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(from)) findDefined(from, keys);
            props.keys = keys.size ? Array.from(keys) : null;
            return props;
        }
        function declareUpdate(props) {
            const update = createUpdate(props);
            if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(update.default)) {
                update.default = getDefaultProps(update);
            }
            return update;
        }
        function findDefined(values, keys) {
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(values, ((value, key) => value != null && keys.add(key)));
        }
        const ACTIVE_EVENTS = [ "onStart", "onRest", "onChange", "onPause", "onResume" ];
        function mergeActiveFn(target, props, type) {
            target.animation[type] = props[type] !== getDefaultProp(props, type) ? resolveProp(props[type], target.key) : undefined;
        }
        function sendEvent(target, type, ...args) {
            var _target$animation$typ, _target$animation, _target$defaultProps$, _target$defaultProps;
            (_target$animation$typ = (_target$animation = target.animation)[type]) == null ? void 0 : _target$animation$typ.call(_target$animation, ...args);
            (_target$defaultProps$ = (_target$defaultProps = target.defaultProps)[type]) == null ? void 0 : _target$defaultProps$.call(_target$defaultProps, ...args);
        }
        const BATCHED_EVENTS = [ "onStart", "onChange", "onRest" ];
        let nextId = 1;
        class Controller {
            constructor(props, flush) {
                this.id = nextId++;
                this.springs = {};
                this.queue = [];
                this.ref = void 0;
                this._flush = void 0;
                this._initialProps = void 0;
                this._lastAsyncId = 0;
                this._active = new Set;
                this._changed = new Set;
                this._started = false;
                this._item = void 0;
                this._state = {
                    paused: false,
                    pauseQueue: new Set,
                    resumeQueue: new Set,
                    timeouts: new Set
                };
                this._events = {
                    onStart: new Map,
                    onChange: new Map,
                    onRest: new Map
                };
                this._onFrame = this._onFrame.bind(this);
                if (flush) {
                    this._flush = flush;
                }
                if (props) {
                    this.start(_extends({
                        default: true
                    }, props));
                }
            }
            get idle() {
                return !this._state.asyncTo && Object.values(this.springs).every((spring => spring.idle && !spring.isDelayed && !spring.isPaused));
            }
            get item() {
                return this._item;
            }
            set item(item) {
                this._item = item;
            }
            get() {
                const values = {};
                this.each(((spring, key) => values[key] = spring.get()));
                return values;
            }
            set(values) {
                for (const key in values) {
                    const value = values[key];
                    if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(value)) {
                        this.springs[key].set(value);
                    }
                }
            }
            update(props) {
                if (props) {
                    this.queue.push(createUpdate(props));
                }
                return this;
            }
            start(props) {
                let {queue} = this;
                if (props) {
                    queue = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(props).map(createUpdate);
                } else {
                    this.queue = [];
                }
                if (this._flush) {
                    return this._flush(this, queue);
                }
                prepareKeys(this, queue);
                return flushUpdateQueue(this, queue);
            }
            stop(arg, keys) {
                if (arg !== !!arg) {
                    keys = arg;
                }
                if (keys) {
                    const springs = this.springs;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(keys), (key => springs[key].stop(!!arg)));
                } else {
                    stopAsync(this._state, this._lastAsyncId);
                    this.each((spring => spring.stop(!!arg)));
                }
                return this;
            }
            pause(keys) {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(keys)) {
                    this.start({
                        pause: true
                    });
                } else {
                    const springs = this.springs;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(keys), (key => springs[key].pause()));
                }
                return this;
            }
            resume(keys) {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(keys)) {
                    this.start({
                        pause: false
                    });
                } else {
                    const springs = this.springs;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(keys), (key => springs[key].resume()));
                }
                return this;
            }
            each(iterator) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(this.springs, iterator);
            }
            _onFrame() {
                const {onStart, onChange, onRest} = this._events;
                const active = this._active.size > 0;
                const changed = this._changed.size > 0;
                if (active && !this._started || changed && !this._started) {
                    this._started = true;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flush)(onStart, (([onStart, result]) => {
                        result.value = this.get();
                        onStart(result, this, this._item);
                    }));
                }
                const idle = !active && this._started;
                const values = changed || idle && onRest.size ? this.get() : null;
                if (changed && onChange.size) {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flush)(onChange, (([onChange, result]) => {
                        result.value = values;
                        onChange(result, this, this._item);
                    }));
                }
                if (idle) {
                    this._started = false;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flush)(onRest, (([onRest, result]) => {
                        result.value = values;
                        onRest(result, this, this._item);
                    }));
                }
            }
            eventObserved(event) {
                if (event.type == "change") {
                    this._changed.add(event.parent);
                    if (!event.idle) {
                        this._active.add(event.parent);
                    }
                } else if (event.type == "idle") {
                    this._active.delete(event.parent);
                } else return;
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.onFrame(this._onFrame);
            }
        }
        function flushUpdateQueue(ctrl, queue) {
            return Promise.all(queue.map((props => flushUpdate(ctrl, props)))).then((results => getCombinedResult(ctrl, results)));
        }
        async function flushUpdate(ctrl, props, isLoop) {
            const {keys, to, from, loop, onRest, onResolve} = props;
            const defaults = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(props.default) && props.default;
            if (loop) {
                props.loop = false;
            }
            if (to === false) props.to = null;
            if (from === false) props.from = null;
            const asyncTo = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(to) || _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(to) ? to : undefined;
            if (asyncTo) {
                props.to = undefined;
                props.onRest = undefined;
                if (defaults) {
                    defaults.onRest = undefined;
                }
            } else {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(BATCHED_EVENTS, (key => {
                    const handler = props[key];
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(handler)) {
                        const queue = ctrl["_events"][key];
                        props[key] = ({finished, cancelled}) => {
                            const result = queue.get(handler);
                            if (result) {
                                if (!finished) result.finished = false;
                                if (cancelled) result.cancelled = true;
                            } else {
                                queue.set(handler, {
                                    value: null,
                                    finished: finished || false,
                                    cancelled: cancelled || false
                                });
                            }
                        };
                        if (defaults) {
                            defaults[key] = props[key];
                        }
                    }
                }));
            }
            const state = ctrl["_state"];
            if (props.pause === !state.paused) {
                state.paused = props.pause;
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.flushCalls)(props.pause ? state.pauseQueue : state.resumeQueue);
            } else if (state.paused) {
                props.pause = true;
            }
            const promises = (keys || Object.keys(ctrl.springs)).map((key => ctrl.springs[key].start(props)));
            const cancel = props.cancel === true || getDefaultProp(props, "cancel") === true;
            if (asyncTo || cancel && state.asyncId) {
                promises.push(scheduleProps(++ctrl["_lastAsyncId"], {
                    props,
                    state,
                    actions: {
                        pause: _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.noop,
                        resume: _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.noop,
                        start(props, resolve) {
                            if (cancel) {
                                stopAsync(state, ctrl["_lastAsyncId"]);
                                resolve(getCancelledResult(ctrl));
                            } else {
                                props.onRest = onRest;
                                resolve(runAsync(asyncTo, props, state, ctrl));
                            }
                        }
                    }
                }));
            }
            if (state.paused) {
                await new Promise((resume => {
                    state.resumeQueue.add(resume);
                }));
            }
            const result = getCombinedResult(ctrl, await Promise.all(promises));
            if (loop && result.finished && !(isLoop && result.noop)) {
                const nextProps = createLoopUpdate(props, loop, to);
                if (nextProps) {
                    prepareKeys(ctrl, [ nextProps ]);
                    return flushUpdate(ctrl, nextProps, true);
                }
            }
            if (onResolve) {
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => onResolve(result, ctrl, ctrl.item)));
            }
            return result;
        }
        function getSprings(ctrl, props) {
            const springs = _extends({}, ctrl.springs);
            if (props) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(props), (props => {
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props.keys)) {
                        props = createUpdate(props);
                    }
                    if (!_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(props.to)) {
                        props = _extends({}, props, {
                            to: undefined
                        });
                    }
                    prepareSprings(springs, props, (key => createSpring(key)));
                }));
            }
            setSprings(ctrl, springs);
            return springs;
        }
        function setSprings(ctrl, springs) {
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(springs, ((spring, key) => {
                if (!ctrl.springs[key]) {
                    ctrl.springs[key] = spring;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.addFluidObserver)(spring, ctrl);
                }
            }));
        }
        function createSpring(key, observer) {
            const spring = new SpringValue;
            spring.key = key;
            if (observer) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.addFluidObserver)(spring, observer);
            }
            return spring;
        }
        function prepareSprings(springs, props, create) {
            if (props.keys) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(props.keys, (key => {
                    const spring = springs[key] || (springs[key] = create(key));
                    spring["_prepareNode"](props);
                }));
            }
        }
        function prepareKeys(ctrl, queue) {
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(queue, (props => {
                prepareSprings(ctrl.springs, props, (key => createSpring(key, ctrl)));
            }));
        }
        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;
        }
        const _excluded$3 = [ "children" ];
        const SpringContext = _ref => {
            let {children} = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded$3);
            const inherited = (0, react__WEBPACK_IMPORTED_MODULE_1__.useContext)(ctx);
            const pause = props.pause || !!inherited.pause, immediate = props.immediate || !!inherited.immediate;
            props = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useMemoOne)((() => ({
                pause,
                immediate
            })), [ pause, immediate ]);
            const {Provider} = ctx;
            return react__WEBPACK_IMPORTED_MODULE_1__.createElement(Provider, {
                value: props
            }, children);
        };
        const ctx = makeContext(SpringContext, {});
        SpringContext.Provider = ctx.Provider;
        SpringContext.Consumer = ctx.Consumer;
        function makeContext(target, init) {
            Object.assign(target, react__WEBPACK_IMPORTED_MODULE_1__.createContext(init));
            target.Provider._context = target;
            target.Consumer._context = target;
            return target;
        }
        const SpringRef = () => {
            const current = [];
            const SpringRef = function SpringRef(props) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.deprecateDirectCall)();
                const results = [];
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, ((ctrl, i) => {
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props)) {
                        results.push(ctrl.start());
                    } else {
                        const update = _getProps(props, ctrl, i);
                        if (update) {
                            results.push(ctrl.start(update));
                        }
                    }
                }));
                return results;
            };
            SpringRef.current = current;
            SpringRef.add = function(ctrl) {
                if (!current.includes(ctrl)) {
                    current.push(ctrl);
                }
            };
            SpringRef.delete = function(ctrl) {
                const i = current.indexOf(ctrl);
                if (~i) current.splice(i, 1);
            };
            SpringRef.pause = function() {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, (ctrl => ctrl.pause(...arguments)));
                return this;
            };
            SpringRef.resume = function() {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, (ctrl => ctrl.resume(...arguments)));
                return this;
            };
            SpringRef.set = function(values) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, (ctrl => ctrl.set(values)));
            };
            SpringRef.start = function(props) {
                const results = [];
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, ((ctrl, i) => {
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(props)) {
                        results.push(ctrl.start());
                    } else {
                        const update = this._getProps(props, ctrl, i);
                        if (update) {
                            results.push(ctrl.start(update));
                        }
                    }
                }));
                return results;
            };
            SpringRef.stop = function() {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, (ctrl => ctrl.stop(...arguments)));
                return this;
            };
            SpringRef.update = function(props) {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(current, ((ctrl, i) => ctrl.update(this._getProps(props, ctrl, i))));
                return this;
            };
            const _getProps = function _getProps(arg, ctrl, index) {
                return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(arg) ? arg(index, ctrl) : arg;
            };
            SpringRef._getProps = _getProps;
            return SpringRef;
        };
        function useSprings(length, props, deps) {
            const propsFn = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(props) && props;
            if (propsFn && !deps) deps = [];
            const ref = (0, react__WEBPACK_IMPORTED_MODULE_1__.useMemo)((() => propsFn || arguments.length == 3 ? SpringRef() : void 0), []);
            const layoutId = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)(0);
            const forceUpdate = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useForceUpdate)();
            const state = (0, react__WEBPACK_IMPORTED_MODULE_1__.useMemo)((() => ({
                ctrls: [],
                queue: [],
                flush(ctrl, updates) {
                    const springs = getSprings(ctrl, updates);
                    const canFlushSync = layoutId.current > 0 && !state.queue.length && !Object.keys(springs).some((key => !ctrl.springs[key]));
                    return canFlushSync ? flushUpdateQueue(ctrl, updates) : new Promise((resolve => {
                        setSprings(ctrl, springs);
                        state.queue.push((() => {
                            resolve(flushUpdateQueue(ctrl, updates));
                        }));
                        forceUpdate();
                    }));
                }
            })), []);
            const ctrls = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)([ ...state.ctrls ]);
            const updates = [];
            const prevLength = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.usePrev)(length) || 0;
            (0, react__WEBPACK_IMPORTED_MODULE_1__.useMemo)((() => {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(ctrls.current.slice(length, prevLength), (ctrl => {
                    detachRefs(ctrl, ref);
                    ctrl.stop(true);
                }));
                ctrls.current.length = length;
                declareUpdates(prevLength, length);
            }), [ length ]);
            (0, react__WEBPACK_IMPORTED_MODULE_1__.useMemo)((() => {
                declareUpdates(0, Math.min(prevLength, length));
            }), deps);
            function declareUpdates(startIndex, endIndex) {
                for (let i = startIndex; i < endIndex; i++) {
                    const ctrl = ctrls.current[i] || (ctrls.current[i] = new Controller(null, state.flush));
                    const update = propsFn ? propsFn(i, ctrl) : props[i];
                    if (update) {
                        updates[i] = declareUpdate(update);
                    }
                }
            }
            const springs = ctrls.current.map(((ctrl, i) => getSprings(ctrl, updates[i])));
            const context = (0, react__WEBPACK_IMPORTED_MODULE_1__.useContext)(SpringContext);
            const prevContext = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.usePrev)(context);
            const hasContext = context !== prevContext && hasProps(context);
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                layoutId.current++;
                state.ctrls = ctrls.current;
                const {queue} = state;
                if (queue.length) {
                    state.queue = [];
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(queue, (cb => cb()));
                }
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(ctrls.current, ((ctrl, i) => {
                    ref == null ? void 0 : ref.add(ctrl);
                    if (hasContext) {
                        ctrl.start({
                            default: context
                        });
                    }
                    const update = updates[i];
                    if (update) {
                        replaceRef(ctrl, update.ref);
                        if (ctrl.ref) {
                            ctrl.queue.push(update);
                        } else {
                            ctrl.start(update);
                        }
                    }
                }));
            }));
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useOnce)((() => () => {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(state.ctrls, (ctrl => ctrl.stop(true)));
            }));
            const values = springs.map((x => _extends({}, x)));
            return ref ? [ values, ref ] : values;
        }
        function useSpring(props, deps) {
            const isFn = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(props);
            const [[values], ref] = useSprings(1, isFn ? props : [ props ], isFn ? deps || [] : deps);
            return isFn || arguments.length == 2 ? [ values, ref ] : values;
        }
        const initSpringRef = () => SpringRef();
        const useSpringRef = () => (0, react__WEBPACK_IMPORTED_MODULE_1__.useState)(initSpringRef)[0];
        function useTrail(length, propsArg, deps) {
            var _passedRef;
            const propsFn = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(propsArg) && propsArg;
            if (propsFn && !deps) deps = [];
            let reverse = true;
            let passedRef = undefined;
            const result = useSprings(length, ((i, ctrl) => {
                const props = propsFn ? propsFn(i, ctrl) : propsArg;
                passedRef = props.ref;
                reverse = reverse && props.reverse;
                return props;
            }), deps || [ {} ]);
            const ref = (_passedRef = passedRef) != null ? _passedRef : result[1];
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(ref.current, ((ctrl, i) => {
                    const parent = ref.current[i + (reverse ? 1 : -1)];
                    if (parent) {
                        ctrl.start({
                            to: parent.springs
                        });
                    } else {
                        ctrl.start();
                    }
                }));
            }), deps);
            if (propsFn || arguments.length == 3) {
                ref["_getProps"] = (propsArg, ctrl, i) => {
                    const props = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(propsArg) ? propsArg(i, ctrl) : propsArg;
                    if (props) {
                        const parent = ref.current[i + (props.reverse ? 1 : -1)];
                        if (parent) props.to = parent.springs;
                        return props;
                    }
                };
                return result;
            }
            ref["start"] = propsArg => {
                const results = [];
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(ref.current, ((ctrl, i) => {
                    const props = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(propsArg) ? propsArg(i, ctrl) : propsArg;
                    const parent = ref.current[i + (reverse ? 1 : -1)];
                    if (parent) {
                        results.push(ctrl.start(_extends({}, props, {
                            to: parent.springs
                        })));
                    } else {
                        results.push(ctrl.start(_extends({}, props)));
                    }
                }));
                return results;
            };
            return result[0];
        }
        let TransitionPhase;
        (function(TransitionPhase) {
            TransitionPhase["MOUNT"] = "mount";
            TransitionPhase["ENTER"] = "enter";
            TransitionPhase["UPDATE"] = "update";
            TransitionPhase["LEAVE"] = "leave";
        })(TransitionPhase || (TransitionPhase = {}));
        function useTransition(data, props, deps) {
            const propsFn = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(props) && props;
            const {reset, sort, trail = 0, expires = true, exitBeforeEnter = false, onDestroyed, ref: propsRef, config: propsConfig} = propsFn ? propsFn() : props;
            const ref = (0, react__WEBPACK_IMPORTED_MODULE_1__.useMemo)((() => propsFn || arguments.length == 3 ? SpringRef() : void 0), []);
            const items = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(data);
            const transitions = [];
            const usedTransitions = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)(null);
            const prevTransitions = reset ? null : usedTransitions.current;
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                usedTransitions.current = transitions;
            }));
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useOnce)((() => {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(usedTransitions.current, (t => {
                    var _t$ctrl$ref;
                    (_t$ctrl$ref = t.ctrl.ref) == null ? void 0 : _t$ctrl$ref.add(t.ctrl);
                    const change = changes.get(t);
                    if (change) {
                        t.ctrl.start(change.payload);
                    }
                }));
                return () => {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(usedTransitions.current, (t => {
                        if (t.expired) {
                            clearTimeout(t.expirationId);
                        }
                        detachRefs(t.ctrl, ref);
                        t.ctrl.stop(true);
                    }));
                };
            }));
            const keys = getKeys(items, propsFn ? propsFn() : props, prevTransitions);
            const expired = reset && usedTransitions.current || [];
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => (0, 
            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(expired, (({ctrl, item, key}) => {
                detachRefs(ctrl, ref);
                callProp(onDestroyed, item, key);
            }))));
            const reused = [];
            if (prevTransitions) (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(prevTransitions, ((t, i) => {
                if (t.expired) {
                    clearTimeout(t.expirationId);
                    expired.push(t);
                } else {
                    i = reused[i] = keys.indexOf(t.key);
                    if (~i) transitions[i] = t;
                }
            }));
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(items, ((item, i) => {
                if (!transitions[i]) {
                    transitions[i] = {
                        key: keys[i],
                        item,
                        phase: TransitionPhase.MOUNT,
                        ctrl: new Controller
                    };
                    transitions[i].ctrl.item = item;
                }
            }));
            if (reused.length) {
                let i = -1;
                const {leave} = propsFn ? propsFn() : props;
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(reused, ((keyIndex, prevIndex) => {
                    const t = prevTransitions[prevIndex];
                    if (~keyIndex) {
                        i = transitions.indexOf(t);
                        transitions[i] = _extends({}, t, {
                            item: items[keyIndex]
                        });
                    } else if (leave) {
                        transitions.splice(++i, 0, t);
                    }
                }));
            }
            if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(sort)) {
                transitions.sort(((a, b) => sort(a.item, b.item)));
            }
            let delay = -trail;
            const forceUpdate = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useForceUpdate)();
            const defaultProps = getDefaultProps(props);
            const changes = new Map;
            const exitingTransitions = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)(new Map);
            const forceChange = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)(false);
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(transitions, ((t, i) => {
                const key = t.key;
                const prevPhase = t.phase;
                const p = propsFn ? propsFn() : props;
                let to;
                let phase;
                let propsDelay = callProp(p.delay || 0, key);
                if (prevPhase == TransitionPhase.MOUNT) {
                    to = p.enter;
                    phase = TransitionPhase.ENTER;
                } else {
                    const isLeave = keys.indexOf(key) < 0;
                    if (prevPhase != TransitionPhase.LEAVE) {
                        if (isLeave) {
                            to = p.leave;
                            phase = TransitionPhase.LEAVE;
                        } else if (to = p.update) {
                            phase = TransitionPhase.UPDATE;
                        } else return;
                    } else if (!isLeave) {
                        to = p.enter;
                        phase = TransitionPhase.ENTER;
                    } else return;
                }
                to = callProp(to, t.item, i);
                to = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.obj(to) ? inferTo(to) : {
                    to
                };
                if (!to.config) {
                    const config = propsConfig || defaultProps.config;
                    to.config = callProp(config, t.item, i, phase);
                }
                delay += trail;
                const payload = _extends({}, defaultProps, {
                    delay: propsDelay + delay,
                    ref: propsRef,
                    immediate: p.immediate,
                    reset: false
                }, to);
                if (phase == TransitionPhase.ENTER && _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(payload.from)) {
                    const _p = propsFn ? propsFn() : props;
                    const from = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(_p.initial) || prevTransitions ? _p.from : _p.initial;
                    payload.from = callProp(from, t.item, i);
                }
                const {onResolve} = payload;
                payload.onResolve = result => {
                    callProp(onResolve, result);
                    const transitions = usedTransitions.current;
                    const t = transitions.find((t => t.key === key));
                    if (!t) return;
                    if (result.cancelled && t.phase != TransitionPhase.UPDATE) {
                        return;
                    }
                    if (t.ctrl.idle) {
                        const idle = transitions.every((t => t.ctrl.idle));
                        if (t.phase == TransitionPhase.LEAVE) {
                            const expiry = callProp(expires, t.item);
                            if (expiry !== false) {
                                const expiryMs = expiry === true ? 0 : expiry;
                                t.expired = true;
                                if (!idle && expiryMs > 0) {
                                    if (expiryMs <= 2147483647) t.expirationId = setTimeout(forceUpdate, expiryMs);
                                    return;
                                }
                            }
                        }
                        if (idle && transitions.some((t => t.expired))) {
                            exitingTransitions.current.delete(t);
                            if (exitBeforeEnter) {
                                forceChange.current = true;
                            }
                            forceUpdate();
                        }
                    }
                };
                const springs = getSprings(t.ctrl, payload);
                if (phase === TransitionPhase.LEAVE && exitBeforeEnter) {
                    exitingTransitions.current.set(t, {
                        phase,
                        springs,
                        payload
                    });
                } else {
                    changes.set(t, {
                        phase,
                        springs,
                        payload
                    });
                }
            }));
            const context = (0, react__WEBPACK_IMPORTED_MODULE_1__.useContext)(SpringContext);
            const prevContext = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.usePrev)(context);
            const hasContext = context !== prevContext && hasProps(context);
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                if (hasContext) {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(transitions, (t => {
                        t.ctrl.start({
                            default: context
                        });
                    }));
                }
            }), [ context ]);
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(changes, ((_, t) => {
                if (exitingTransitions.current.size) {
                    const ind = transitions.findIndex((state => state.key === t.key));
                    transitions.splice(ind, 1);
                }
            }));
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(exitingTransitions.current.size ? exitingTransitions.current : changes, (({phase, payload}, t) => {
                    const {ctrl} = t;
                    t.phase = phase;
                    ref == null ? void 0 : ref.add(ctrl);
                    if (hasContext && phase == TransitionPhase.ENTER) {
                        ctrl.start({
                            default: context
                        });
                    }
                    if (payload) {
                        replaceRef(ctrl, payload.ref);
                        if (ctrl.ref && !forceChange.current) {
                            ctrl.update(payload);
                        } else {
                            ctrl.start(payload);
                            if (forceChange.current) {
                                forceChange.current = false;
                            }
                        }
                    }
                }));
            }), reset ? void 0 : deps);
            const renderTransitions = render => react__WEBPACK_IMPORTED_MODULE_1__.createElement(react__WEBPACK_IMPORTED_MODULE_1__.Fragment, null, transitions.map(((t, i) => {
                const {springs} = changes.get(t) || t.ctrl;
                const elem = render(_extends({}, springs), t.item, t, i);
                return elem && elem.type ? react__WEBPACK_IMPORTED_MODULE_1__.createElement(elem.type, _extends({}, elem.props, {
                    key: _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.str(t.key) || _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.num(t.key) ? t.key : t.ctrl.id,
                    ref: elem.ref
                })) : elem;
            })));
            return ref ? [ renderTransitions, ref ] : renderTransitions;
        }
        let nextKey = 1;
        function getKeys(items, {key, keys = key}, prevTransitions) {
            if (keys === null) {
                const reused = new Set;
                return items.map((item => {
                    const t = prevTransitions && prevTransitions.find((t => t.item === item && t.phase !== TransitionPhase.LEAVE && !reused.has(t)));
                    if (t) {
                        reused.add(t);
                        return t.key;
                    }
                    return nextKey++;
                }));
            }
            return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.und(keys) ? items : _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(keys) ? items.map(keys) : (0, 
            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(keys);
        }
        const _excluded$2 = [ "children" ];
        function Spring(_ref) {
            let {children} = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded$2);
            return children(useSpring(props));
        }
        const _excluded$1 = [ "items", "children" ];
        function Trail(_ref) {
            let {items, children} = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded$1);
            const trails = useTrail(items.length, props);
            return items.map(((item, index) => {
                const result = children(item, index);
                return _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(result) ? result(trails[index]) : result;
            }));
        }
        const _excluded = [ "items", "children" ];
        function Transition(_ref) {
            let {items, children} = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded);
            return useTransition(items, props)(children);
        }
        class Interpolation extends FrameValue {
            constructor(source, args) {
                super();
                this.key = void 0;
                this.idle = true;
                this.calc = void 0;
                this._active = new Set;
                this.source = source;
                this.calc = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.createInterpolator)(...args);
                const value = this._get();
                const nodeType = (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimatedType)(value);
                (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.setAnimated)(this, nodeType.create(value));
            }
            advance(_dt) {
                const value = this._get();
                const oldValue = this.get();
                if (!(0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isEqual)(value, oldValue)) {
                    (0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getAnimated)(this).setValue(value);
                    this._onChange(value, this.idle);
                }
                if (!this.idle && checkIdle(this._active)) {
                    becomeIdle(this);
                }
            }
            _get() {
                const inputs = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(this.source) ? this.source.map(_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue) : (0, 
                _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(this.source));
                return this.calc(...inputs);
            }
            _start() {
                if (this.idle && !checkIdle(this._active)) {
                    this.idle = false;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getPayload)(this), (node => {
                        node.done = false;
                    }));
                    if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.skipAnimation) {
                        _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates((() => this.advance()));
                        becomeIdle(this);
                    } else {
                        _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.frameLoop.start(this);
                    }
                }
            }
            _attach() {
                let priority = 1;
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(this.source), (source => {
                    if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(source)) {
                        (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.addFluidObserver)(source, this);
                    }
                    if (isFrameValue(source)) {
                        if (!source.idle) {
                            this._active.add(source);
                        }
                        priority = Math.max(priority, source.priority + 1);
                    }
                }));
                this.priority = priority;
                this._start();
            }
            _detach() {
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(this.source), (source => {
                    if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(source)) {
                        (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.removeFluidObserver)(source, this);
                    }
                }));
                this._active.clear();
                becomeIdle(this);
            }
            eventObserved(event) {
                if (event.type == "change") {
                    if (event.idle) {
                        this.advance();
                    } else {
                        this._active.add(event.parent);
                        this._start();
                    }
                } else if (event.type == "idle") {
                    this._active.delete(event.parent);
                } else if (event.type == "priority") {
                    this.priority = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(this.source).reduce(((highest, parent) => Math.max(highest, (isFrameValue(parent) ? parent.priority : 0) + 1)), 0);
                }
            }
        }
        function isIdle(source) {
            return source.idle !== false;
        }
        function checkIdle(active) {
            return !active.size || Array.from(active).every(isIdle);
        }
        function becomeIdle(self) {
            if (!self.idle) {
                self.idle = true;
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)((0, _react_spring_animated__WEBPACK_IMPORTED_MODULE_2__.getPayload)(self), (node => {
                    node.done = true;
                }));
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.callFluidObservers)(self, {
                    type: "idle",
                    parent: self
                });
            }
        }
        const to = (source, ...args) => new Interpolation(source, args);
        const interpolate = (source, ...args) => ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.deprecateInterpolate)(), 
        new Interpolation(source, args));
        _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.Globals.assign({
            createStringInterpolator: _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.createStringInterpolator,
            to: (source, args) => new Interpolation(source, args)
        });
        const update = _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.frameLoop.advance;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            FluidValue: () => FluidValue,
            Globals: () => globals,
            addFluidObserver: () => addFluidObserver,
            callFluidObserver: () => callFluidObserver,
            callFluidObservers: () => callFluidObservers,
            colorToRgba: () => colorToRgba,
            colors: () => colors,
            createInterpolator: () => createInterpolator,
            createStringInterpolator: () => createStringInterpolator,
            defineHidden: () => defineHidden,
            deprecateDirectCall: () => deprecateDirectCall,
            deprecateInterpolate: () => deprecateInterpolate,
            each: () => each,
            eachProp: () => eachProp,
            flush: () => flush,
            flushCalls: () => flushCalls,
            frameLoop: () => frameLoop,
            getFluidObservers: () => getFluidObservers,
            getFluidValue: () => getFluidValue,
            hasFluidValue: () => hasFluidValue,
            hex3: () => hex3,
            hex4: () => hex4,
            hex6: () => hex6,
            hex8: () => hex8,
            hsl: () => hsl,
            hsla: () => hsla,
            is: () => is,
            isAnimatedString: () => isAnimatedString,
            isEqual: () => isEqual,
            isSSR: () => isSSR,
            noop: () => noop,
            raf: () => _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf,
            removeFluidObserver: () => removeFluidObserver,
            rgb: () => rgb,
            rgba: () => rgba,
            setFluidGetter: () => setFluidGetter,
            toArray: () => toArray,
            useForceUpdate: () => useForceUpdate,
            useLayoutEffect: () => useLayoutEffect,
            useMemoOne: () => useMemoOne,
            useOnce: () => useOnce,
            usePrev: () => usePrev
        });
        var _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(183);
        var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
        function noop() {}
        const defineHidden = (obj, key, value) => Object.defineProperty(obj, key, {
            value,
            writable: true,
            configurable: true
        });
        const is = {
            arr: Array.isArray,
            obj: a => !!a && a.constructor.name === "Object",
            fun: a => typeof a === "function",
            str: a => typeof a === "string",
            num: a => typeof a === "number",
            und: a => a === undefined
        };
        function isEqual(a, b) {
            if (is.arr(a)) {
                if (!is.arr(b) || a.length !== b.length) return false;
                for (let i = 0; i < a.length; i++) {
                    if (a[i] !== b[i]) return false;
                }
                return true;
            }
            return a === b;
        }
        const each = (obj, fn) => obj.forEach(fn);
        function eachProp(obj, fn, ctx) {
            if (is.arr(obj)) {
                for (let i = 0; i < obj.length; i++) {
                    fn.call(ctx, obj[i], `${i}`);
                }
                return;
            }
            for (const key in obj) {
                if (obj.hasOwnProperty(key)) {
                    fn.call(ctx, obj[key], key);
                }
            }
        }
        const toArray = a => is.und(a) ? [] : is.arr(a) ? a : [ a ];
        function flush(queue, iterator) {
            if (queue.size) {
                const items = Array.from(queue);
                queue.clear();
                each(items, iterator);
            }
        }
        const flushCalls = (queue, ...args) => flush(queue, (fn => fn(...args)));
        const isSSR = () => typeof window === "undefined" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent);
        let createStringInterpolator$1;
        let to;
        let colors$1 = null;
        let skipAnimation = false;
        let willAdvance = noop;
        const assign = globals => {
            if (globals.to) to = globals.to;
            if (globals.now) _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf.now = globals.now;
            if (globals.colors !== undefined) colors$1 = globals.colors;
            if (globals.skipAnimation != null) skipAnimation = globals.skipAnimation;
            if (globals.createStringInterpolator) createStringInterpolator$1 = globals.createStringInterpolator;
            if (globals.requestAnimationFrame) _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf.use(globals.requestAnimationFrame);
            if (globals.batchedUpdates) _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf.batchedUpdates = globals.batchedUpdates;
            if (globals.willAdvance) willAdvance = globals.willAdvance;
            if (globals.frameLoop) _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf.frameLoop = globals.frameLoop;
        };
        var globals = Object.freeze({
            __proto__: null,
            get createStringInterpolator() {
                return createStringInterpolator$1;
            },
            get to() {
                return to;
            },
            get colors() {
                return colors$1;
            },
            get skipAnimation() {
                return skipAnimation;
            },
            get willAdvance() {
                return willAdvance;
            },
            assign
        });
        const startQueue = new Set;
        let currentFrame = [];
        let prevFrame = [];
        let priority = 0;
        const frameLoop = {
            get idle() {
                return !startQueue.size && !currentFrame.length;
            },
            start(animation) {
                if (priority > animation.priority) {
                    startQueue.add(animation);
                    _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf.onStart(flushStartQueue);
                } else {
                    startSafely(animation);
                    (0, _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf)(advance);
                }
            },
            advance,
            sort(animation) {
                if (priority) {
                    _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf.onFrame((() => frameLoop.sort(animation)));
                } else {
                    const prevIndex = currentFrame.indexOf(animation);
                    if (~prevIndex) {
                        currentFrame.splice(prevIndex, 1);
                        startUnsafely(animation);
                    }
                }
            },
            clear() {
                currentFrame = [];
                startQueue.clear();
            }
        };
        function flushStartQueue() {
            startQueue.forEach(startSafely);
            startQueue.clear();
            (0, _react_spring_rafz__WEBPACK_IMPORTED_MODULE_0__.raf)(advance);
        }
        function startSafely(animation) {
            if (!currentFrame.includes(animation)) startUnsafely(animation);
        }
        function startUnsafely(animation) {
            currentFrame.splice(findIndex(currentFrame, (other => other.priority > animation.priority)), 0, animation);
        }
        function advance(dt) {
            const nextFrame = prevFrame;
            for (let i = 0; i < currentFrame.length; i++) {
                const animation = currentFrame[i];
                priority = animation.priority;
                if (!animation.idle) {
                    willAdvance(animation);
                    animation.advance(dt);
                    if (!animation.idle) {
                        nextFrame.push(animation);
                    }
                }
            }
            priority = 0;
            prevFrame = currentFrame;
            prevFrame.length = 0;
            currentFrame = nextFrame;
            return currentFrame.length > 0;
        }
        function findIndex(arr, test) {
            const index = arr.findIndex(test);
            return index < 0 ? arr.length : index;
        }
        const colors = {
            transparent: 0,
            aliceblue: 4042850303,
            antiquewhite: 4209760255,
            aqua: 16777215,
            aquamarine: 2147472639,
            azure: 4043309055,
            beige: 4126530815,
            bisque: 4293182719,
            black: 255,
            blanchedalmond: 4293643775,
            blue: 65535,
            blueviolet: 2318131967,
            brown: 2771004159,
            burlywood: 3736635391,
            burntsienna: 3934150143,
            cadetblue: 1604231423,
            chartreuse: 2147418367,
            chocolate: 3530104575,
            coral: 4286533887,
            cornflowerblue: 1687547391,
            cornsilk: 4294499583,
            crimson: 3692313855,
            cyan: 16777215,
            darkblue: 35839,
            darkcyan: 9145343,
            darkgoldenrod: 3095792639,
            darkgray: 2846468607,
            darkgreen: 6553855,
            darkgrey: 2846468607,
            darkkhaki: 3182914559,
            darkmagenta: 2332068863,
            darkolivegreen: 1433087999,
            darkorange: 4287365375,
            darkorchid: 2570243327,
            darkred: 2332033279,
            darksalmon: 3918953215,
            darkseagreen: 2411499519,
            darkslateblue: 1211993087,
            darkslategray: 793726975,
            darkslategrey: 793726975,
            darkturquoise: 13554175,
            darkviolet: 2483082239,
            deeppink: 4279538687,
            deepskyblue: 12582911,
            dimgray: 1768516095,
            dimgrey: 1768516095,
            dodgerblue: 512819199,
            firebrick: 2988581631,
            floralwhite: 4294635775,
            forestgreen: 579543807,
            fuchsia: 4278255615,
            gainsboro: 3705462015,
            ghostwhite: 4177068031,
            gold: 4292280575,
            goldenrod: 3668254975,
            gray: 2155905279,
            green: 8388863,
            greenyellow: 2919182335,
            grey: 2155905279,
            honeydew: 4043305215,
            hotpink: 4285117695,
            indianred: 3445382399,
            indigo: 1258324735,
            ivory: 4294963455,
            khaki: 4041641215,
            lavender: 3873897215,
            lavenderblush: 4293981695,
            lawngreen: 2096890111,
            lemonchiffon: 4294626815,
            lightblue: 2916673279,
            lightcoral: 4034953471,
            lightcyan: 3774873599,
            lightgoldenrodyellow: 4210742015,
            lightgray: 3553874943,
            lightgreen: 2431553791,
            lightgrey: 3553874943,
            lightpink: 4290167295,
            lightsalmon: 4288707327,
            lightseagreen: 548580095,
            lightskyblue: 2278488831,
            lightslategray: 2005441023,
            lightslategrey: 2005441023,
            lightsteelblue: 2965692159,
            lightyellow: 4294959359,
            lime: 16711935,
            limegreen: 852308735,
            linen: 4210091775,
            magenta: 4278255615,
            maroon: 2147483903,
            mediumaquamarine: 1724754687,
            mediumblue: 52735,
            mediumorchid: 3126187007,
            mediumpurple: 2473647103,
            mediumseagreen: 1018393087,
            mediumslateblue: 2070474495,
            mediumspringgreen: 16423679,
            mediumturquoise: 1221709055,
            mediumvioletred: 3340076543,
            midnightblue: 421097727,
            mintcream: 4127193855,
            mistyrose: 4293190143,
            moccasin: 4293178879,
            navajowhite: 4292783615,
            navy: 33023,
            oldlace: 4260751103,
            olive: 2155872511,
            olivedrab: 1804477439,
            orange: 4289003775,
            orangered: 4282712319,
            orchid: 3664828159,
            palegoldenrod: 4008225535,
            palegreen: 2566625535,
            paleturquoise: 2951671551,
            palevioletred: 3681588223,
            papayawhip: 4293907967,
            peachpuff: 4292524543,
            peru: 3448061951,
            pink: 4290825215,
            plum: 3718307327,
            powderblue: 2967529215,
            purple: 2147516671,
            rebeccapurple: 1714657791,
            red: 4278190335,
            rosybrown: 3163525119,
            royalblue: 1097458175,
            saddlebrown: 2336560127,
            salmon: 4202722047,
            sandybrown: 4104413439,
            seagreen: 780883967,
            seashell: 4294307583,
            sienna: 2689740287,
            silver: 3233857791,
            skyblue: 2278484991,
            slateblue: 1784335871,
            slategray: 1887473919,
            slategrey: 1887473919,
            snow: 4294638335,
            springgreen: 16744447,
            steelblue: 1182971135,
            tan: 3535047935,
            teal: 8421631,
            thistle: 3636451583,
            tomato: 4284696575,
            turquoise: 1088475391,
            violet: 4001558271,
            wheat: 4125012991,
            white: 4294967295,
            whitesmoke: 4126537215,
            yellow: 4294902015,
            yellowgreen: 2597139199
        };
        const NUMBER = "[-+]?\\d*\\.?\\d+";
        const PERCENTAGE = NUMBER + "%";
        function call(...parts) {
            return "\\(\\s*(" + parts.join(")\\s*,\\s*(") + ")\\s*\\)";
        }
        const rgb = new RegExp("rgb" + call(NUMBER, NUMBER, NUMBER));
        const rgba = new RegExp("rgba" + call(NUMBER, NUMBER, NUMBER, NUMBER));
        const hsl = new RegExp("hsl" + call(NUMBER, PERCENTAGE, PERCENTAGE));
        const hsla = new RegExp("hsla" + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
        const hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
        const hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
        const hex6 = /^#([0-9a-fA-F]{6})$/;
        const hex8 = /^#([0-9a-fA-F]{8})$/;
        function normalizeColor(color) {
            let match;
            if (typeof color === "number") {
                return color >>> 0 === color && color >= 0 && color <= 4294967295 ? color : null;
            }
            if (match = hex6.exec(color)) return parseInt(match[1] + "ff", 16) >>> 0;
            if (colors$1 && colors$1[color] !== undefined) {
                return colors$1[color];
            }
            if (match = rgb.exec(color)) {
                return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | 255) >>> 0;
            }
            if (match = rgba.exec(color)) {
                return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | parse1(match[4])) >>> 0;
            }
            if (match = hex3.exec(color)) {
                return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + "ff", 16) >>> 0;
            }
            if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;
            if (match = hex4.exec(color)) {
                return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + match[4] + match[4], 16) >>> 0;
            }
            if (match = hsl.exec(color)) {
                return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | 255) >>> 0;
            }
            if (match = hsla.exec(color)) {
                return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | parse1(match[4])) >>> 0;
            }
            return null;
        }
        function hue2rgb(p, q, t) {
            if (t < 0) t += 1;
            if (t > 1) t -= 1;
            if (t < 1 / 6) return p + (q - p) * 6 * t;
            if (t < 1 / 2) return q;
            if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
            return p;
        }
        function hslToRgb(h, s, l) {
            const q = l < .5 ? l * (1 + s) : l + s - l * s;
            const p = 2 * l - q;
            const r = hue2rgb(p, q, h + 1 / 3);
            const g = hue2rgb(p, q, h);
            const b = hue2rgb(p, q, h - 1 / 3);
            return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
        }
        function parse255(str) {
            const int = parseInt(str, 10);
            if (int < 0) return 0;
            if (int > 255) return 255;
            return int;
        }
        function parse360(str) {
            const int = parseFloat(str);
            return (int % 360 + 360) % 360 / 360;
        }
        function parse1(str) {
            const num = parseFloat(str);
            if (num < 0) return 0;
            if (num > 1) return 255;
            return Math.round(num * 255);
        }
        function parsePercentage(str) {
            const int = parseFloat(str);
            if (int < 0) return 0;
            if (int > 100) return 1;
            return int / 100;
        }
        function colorToRgba(input) {
            let int32Color = normalizeColor(input);
            if (int32Color === null) return input;
            int32Color = int32Color || 0;
            let r = (int32Color & 4278190080) >>> 24;
            let g = (int32Color & 16711680) >>> 16;
            let b = (int32Color & 65280) >>> 8;
            let a = (int32Color & 255) / 255;
            return `rgba(${r}, ${g}, ${b}, ${a})`;
        }
        const createInterpolator = (range, output, extrapolate) => {
            if (is.fun(range)) {
                return range;
            }
            if (is.arr(range)) {
                return createInterpolator({
                    range,
                    output,
                    extrapolate
                });
            }
            if (is.str(range.output[0])) {
                return createStringInterpolator$1(range);
            }
            const config = range;
            const outputRange = config.output;
            const inputRange = config.range || [ 0, 1 ];
            const extrapolateLeft = config.extrapolateLeft || config.extrapolate || "extend";
            const extrapolateRight = config.extrapolateRight || config.extrapolate || "extend";
            const easing = config.easing || (t => t);
            return input => {
                const range = findRange(input, inputRange);
                return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map);
            };
        };
        function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {
            let result = map ? map(input) : input;
            if (result < inputMin) {
                if (extrapolateLeft === "identity") return result; else if (extrapolateLeft === "clamp") result = inputMin;
            }
            if (result > inputMax) {
                if (extrapolateRight === "identity") return result; else if (extrapolateRight === "clamp") result = inputMax;
            }
            if (outputMin === outputMax) return outputMin;
            if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax;
            if (inputMin === -Infinity) result = -result; else if (inputMax === Infinity) result = result - inputMin; else result = (result - inputMin) / (inputMax - inputMin);
            result = easing(result);
            if (outputMin === -Infinity) result = -result; else if (outputMax === Infinity) result = result + outputMin; else result = result * (outputMax - outputMin) + outputMin;
            return result;
        }
        function findRange(input, inputRange) {
            for (var i = 1; i < inputRange.length - 1; ++i) if (inputRange[i] >= input) break;
            return i - 1;
        }
        function _extends() {
            _extends = Object.assign || 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);
        }
        const $get = Symbol.for("FluidValue.get");
        const $observers = Symbol.for("FluidValue.observers");
        const hasFluidValue = arg => Boolean(arg && arg[$get]);
        const getFluidValue = arg => arg && arg[$get] ? arg[$get]() : arg;
        const getFluidObservers = target => target[$observers] || null;
        function callFluidObserver(observer, event) {
            if (observer.eventObserved) {
                observer.eventObserved(event);
            } else {
                observer(event);
            }
        }
        function callFluidObservers(target, event) {
            let observers = target[$observers];
            if (observers) {
                observers.forEach((observer => {
                    callFluidObserver(observer, event);
                }));
            }
        }
        class FluidValue {
            constructor(get) {
                this[$get] = void 0;
                this[$observers] = void 0;
                if (!get && !(get = this.get)) {
                    throw Error("Unknown getter");
                }
                setFluidGetter(this, get);
            }
        }
        const setFluidGetter = (target, get) => setHidden(target, $get, get);
        function addFluidObserver(target, observer) {
            if (target[$get]) {
                let observers = target[$observers];
                if (!observers) {
                    setHidden(target, $observers, observers = new Set);
                }
                if (!observers.has(observer)) {
                    observers.add(observer);
                    if (target.observerAdded) {
                        target.observerAdded(observers.size, observer);
                    }
                }
            }
            return observer;
        }
        function removeFluidObserver(target, observer) {
            let observers = target[$observers];
            if (observers && observers.has(observer)) {
                const count = observers.size - 1;
                if (count) {
                    observers.delete(observer);
                } else {
                    target[$observers] = null;
                }
                if (target.observerRemoved) {
                    target.observerRemoved(count, observer);
                }
            }
        }
        const setHidden = (target, key, value) => Object.defineProperty(target, key, {
            value,
            writable: true,
            configurable: true
        });
        const numberRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
        const colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi;
        const unitRegex = new RegExp(`(${numberRegex.source})(%|[a-z]+)`, "i");
        const rgbaRegex = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi;
        const cssVariableRegex = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;
        const variableToRgba = input => {
            const [token, fallback] = parseCSSVariable(input);
            if (!token || isSSR()) {
                return input;
            }
            const value = window.getComputedStyle(document.documentElement).getPropertyValue(token);
            if (value) {
                return value.trim();
            } else if (fallback && fallback.startsWith("--")) {
                const _value = window.getComputedStyle(document.documentElement).getPropertyValue(fallback);
                if (_value) {
                    return _value;
                } else {
                    return input;
                }
            } else if (fallback && cssVariableRegex.test(fallback)) {
                return variableToRgba(fallback);
            } else if (fallback) {
                return fallback;
            }
            return input;
        };
        const parseCSSVariable = current => {
            const match = cssVariableRegex.exec(current);
            if (!match) return [ ,  ];
            const [, token, fallback] = match;
            return [ token, fallback ];
        };
        let namedColorRegex;
        const rgbaRound = (_, p1, p2, p3, p4) => `rgba(${Math.round(p1)}, ${Math.round(p2)}, ${Math.round(p3)}, ${p4})`;
        const createStringInterpolator = config => {
            if (!namedColorRegex) namedColorRegex = colors$1 ? new RegExp(`(${Object.keys(colors$1).join("|")})(?!\\w)`, "g") : /^\b$/;
            const output = config.output.map((value => getFluidValue(value).replace(cssVariableRegex, variableToRgba).replace(colorRegex, colorToRgba).replace(namedColorRegex, colorToRgba)));
            const keyframes = output.map((value => value.match(numberRegex).map(Number)));
            const outputRanges = keyframes[0].map(((_, i) => keyframes.map((values => {
                if (!(i in values)) {
                    throw Error('The arity of each "output" value must be equal');
                }
                return values[i];
            }))));
            const interpolators = outputRanges.map((output => createInterpolator(_extends({}, config, {
                output
            }))));
            return input => {
                var _output$find;
                const missingUnit = !unitRegex.test(output[0]) && ((_output$find = output.find((value => unitRegex.test(value)))) == null ? void 0 : _output$find.replace(numberRegex, ""));
                let i = 0;
                return output[0].replace(numberRegex, (() => `${interpolators[i++](input)}${missingUnit || ""}`)).replace(rgbaRegex, rgbaRound);
            };
        };
        const prefix = "react-spring: ";
        const once = fn => {
            const func = fn;
            let called = false;
            if (typeof func != "function") {
                throw new TypeError(`${prefix}once requires a function parameter`);
            }
            return (...args) => {
                if (!called) {
                    func(...args);
                    called = true;
                }
            };
        };
        const warnInterpolate = once(console.warn);
        function deprecateInterpolate() {
            warnInterpolate(`${prefix}The "interpolate" function is deprecated in v9 (use "to" instead)`);
        }
        const warnDirectCall = once(console.warn);
        function deprecateDirectCall() {
            warnDirectCall(`${prefix}Directly calling start instead of using the api object is deprecated in v9 (use ".start" instead), this will be removed in later 0.X.0 versions`);
        }
        function isAnimatedString(value) {
            return is.str(value) && (value[0] == "#" || /\d/.test(value) || !isSSR() && cssVariableRegex.test(value) || value in (colors$1 || {}));
        }
        const useLayoutEffect = typeof window !== "undefined" && window.document && window.document.createElement ? react__WEBPACK_IMPORTED_MODULE_1__.useLayoutEffect : react__WEBPACK_IMPORTED_MODULE_1__.useEffect;
        const useIsMounted = () => {
            const isMounted = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)(false);
            useLayoutEffect((() => {
                isMounted.current = true;
                return () => {
                    isMounted.current = false;
                };
            }), []);
            return isMounted;
        };
        function useForceUpdate() {
            const update = (0, react__WEBPACK_IMPORTED_MODULE_1__.useState)()[1];
            const isMounted = useIsMounted();
            return () => {
                if (isMounted.current) {
                    update(Math.random());
                }
            };
        }
        function useMemoOne(getResult, inputs) {
            const [initial] = (0, react__WEBPACK_IMPORTED_MODULE_1__.useState)((() => ({
                inputs,
                result: getResult()
            })));
            const committed = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)();
            const prevCache = committed.current;
            let cache = prevCache;
            if (cache) {
                const useCache = Boolean(inputs && cache.inputs && areInputsEqual(inputs, cache.inputs));
                if (!useCache) {
                    cache = {
                        inputs,
                        result: getResult()
                    };
                }
            } else {
                cache = initial;
            }
            (0, react__WEBPACK_IMPORTED_MODULE_1__.useEffect)((() => {
                committed.current = cache;
                if (prevCache == initial) {
                    initial.inputs = initial.result = undefined;
                }
            }), [ cache ]);
            return cache.result;
        }
        function areInputsEqual(next, prev) {
            if (next.length !== prev.length) {
                return false;
            }
            for (let i = 0; i < next.length; i++) {
                if (next[i] !== prev[i]) {
                    return false;
                }
            }
            return true;
        }
        const useOnce = effect => (0, react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(effect, emptyDeps);
        const emptyDeps = [];
        function usePrev(value) {
            const prevRef = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)();
            (0, react__WEBPACK_IMPORTED_MODULE_1__.useEffect)((() => {
                prevRef.current = value;
            }));
            return prevRef.current;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            __raf: () => __raf,
            raf: () => raf
        });
        let updateQueue = makeQueue();
        const raf = fn => schedule(fn, updateQueue);
        let writeQueue = makeQueue();
        raf.write = fn => schedule(fn, writeQueue);
        let onStartQueue = makeQueue();
        raf.onStart = fn => schedule(fn, onStartQueue);
        let onFrameQueue = makeQueue();
        raf.onFrame = fn => schedule(fn, onFrameQueue);
        let onFinishQueue = makeQueue();
        raf.onFinish = fn => schedule(fn, onFinishQueue);
        let timeouts = [];
        raf.setTimeout = (handler, ms) => {
            let time = raf.now() + ms;
            let cancel = () => {
                let i = timeouts.findIndex((t => t.cancel == cancel));
                if (~i) timeouts.splice(i, 1);
                pendingCount -= ~i ? 1 : 0;
            };
            let timeout = {
                time,
                handler,
                cancel
            };
            timeouts.splice(findTimeout(time), 0, timeout);
            pendingCount += 1;
            start();
            return timeout;
        };
        let findTimeout = time => ~(~timeouts.findIndex((t => t.time > time)) || ~timeouts.length);
        raf.cancel = fn => {
            onStartQueue.delete(fn);
            onFrameQueue.delete(fn);
            updateQueue.delete(fn);
            writeQueue.delete(fn);
            onFinishQueue.delete(fn);
        };
        raf.sync = fn => {
            sync = true;
            raf.batchedUpdates(fn);
            sync = false;
        };
        raf.throttle = fn => {
            let lastArgs;
            function queuedFn() {
                try {
                    fn(...lastArgs);
                } finally {
                    lastArgs = null;
                }
            }
            function throttled(...args) {
                lastArgs = args;
                raf.onStart(queuedFn);
            }
            throttled.handler = fn;
            throttled.cancel = () => {
                onStartQueue.delete(queuedFn);
                lastArgs = null;
            };
            return throttled;
        };
        let nativeRaf = typeof window != "undefined" ? window.requestAnimationFrame : () => {};
        raf.use = impl => nativeRaf = impl;
        raf.now = typeof performance != "undefined" ? () => performance.now() : Date.now;
        raf.batchedUpdates = fn => fn();
        raf.catch = console.error;
        raf.frameLoop = "always";
        raf.advance = () => {
            if (raf.frameLoop !== "demand") {
                console.warn("Cannot call the manual advancement of rafz whilst frameLoop is not set as demand");
            } else {
                update();
            }
        };
        let ts = -1;
        let pendingCount = 0;
        let sync = false;
        function schedule(fn, queue) {
            if (sync) {
                queue.delete(fn);
                fn(0);
            } else {
                queue.add(fn);
                start();
            }
        }
        function start() {
            if (ts < 0) {
                ts = 0;
                if (raf.frameLoop !== "demand") {
                    nativeRaf(loop);
                }
            }
        }
        function stop() {
            ts = -1;
        }
        function loop() {
            if (~ts) {
                nativeRaf(loop);
                raf.batchedUpdates(update);
            }
        }
        function update() {
            let prevTs = ts;
            ts = raf.now();
            let count = findTimeout(ts);
            if (count) {
                eachSafely(timeouts.splice(0, count), (t => t.handler()));
                pendingCount -= count;
            }
            onStartQueue.flush();
            updateQueue.flush(prevTs ? Math.min(64, ts - prevTs) : 16.667);
            onFrameQueue.flush();
            writeQueue.flush();
            onFinishQueue.flush();
            if (!pendingCount) {
                stop();
            }
        }
        function makeQueue() {
            let next = new Set;
            let current = next;
            return {
                add(fn) {
                    pendingCount += current == next && !next.has(fn) ? 1 : 0;
                    next.add(fn);
                },
                delete(fn) {
                    pendingCount -= current == next && next.has(fn) ? 1 : 0;
                    return next.delete(fn);
                },
                flush(arg) {
                    if (current.size) {
                        next = new Set;
                        pendingCount -= current.size;
                        eachSafely(current, (fn => fn(arg) && next.add(fn)));
                        pendingCount += next.size;
                        current = next;
                    }
                }
            };
        }
        function eachSafely(values, each) {
            values.forEach((value => {
                try {
                    each(value);
                } catch (e) {
                    raf.catch(e);
                }
            }));
        }
        const __raf = {
            count() {
                return pendingCount;
            },
            isRunning() {
                return ts >= 0;
            },
            clear() {
                ts = -1;
                timeouts = [];
                onStartQueue = makeQueue();
                updateQueue = makeQueue();
                onFrameQueue = makeQueue();
                writeQueue = makeQueue();
                onFinishQueue = makeQueue();
                pendingCount = 0;
            }
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            Animated: () => Animated,
            AnimatedArray: () => AnimatedArray,
            AnimatedObject: () => AnimatedObject,
            AnimatedString: () => AnimatedString,
            AnimatedValue: () => AnimatedValue,
            createHost: () => createHost,
            getAnimated: () => getAnimated,
            getAnimatedType: () => getAnimatedType,
            getPayload: () => getPayload,
            isAnimated: () => isAnimated,
            setAnimated: () => setAnimated
        });
        var _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(182);
        var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
        const $node = Symbol.for("Animated:node");
        const isAnimated = value => !!value && value[$node] === value;
        const getAnimated = owner => owner && owner[$node];
        const setAnimated = (owner, node) => (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.defineHidden)(owner, $node, node);
        const getPayload = owner => owner && owner[$node] && owner[$node].getPayload();
        class Animated {
            constructor() {
                this.payload = void 0;
                setAnimated(this, this);
            }
            getPayload() {
                return this.payload || [];
            }
        }
        class AnimatedValue extends Animated {
            constructor(_value) {
                super();
                this.done = true;
                this.elapsedTime = void 0;
                this.lastPosition = void 0;
                this.lastVelocity = void 0;
                this.v0 = void 0;
                this.durationProgress = 0;
                this._value = _value;
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.num(this._value)) {
                    this.lastPosition = this._value;
                }
            }
            static create(value) {
                return new AnimatedValue(value);
            }
            getPayload() {
                return [ this ];
            }
            getValue() {
                return this._value;
            }
            setValue(value, step) {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.num(value)) {
                    this.lastPosition = value;
                    if (step) {
                        value = Math.round(value / step) * step;
                        if (this.done) {
                            this.lastPosition = value;
                        }
                    }
                }
                if (this._value === value) {
                    return false;
                }
                this._value = value;
                return true;
            }
            reset() {
                const {done} = this;
                this.done = false;
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.num(this._value)) {
                    this.elapsedTime = 0;
                    this.durationProgress = 0;
                    this.lastPosition = this._value;
                    if (done) this.lastVelocity = null;
                    this.v0 = null;
                }
            }
        }
        class AnimatedString extends AnimatedValue {
            constructor(value) {
                super(0);
                this._string = null;
                this._toString = void 0;
                this._toString = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.createInterpolator)({
                    output: [ value, value ]
                });
            }
            static create(value) {
                return new AnimatedString(value);
            }
            getValue() {
                let value = this._string;
                return value == null ? this._string = this._toString(this._value) : value;
            }
            setValue(value) {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.str(value)) {
                    if (value == this._string) {
                        return false;
                    }
                    this._string = value;
                    this._value = 1;
                } else if (super.setValue(value)) {
                    this._string = null;
                } else {
                    return false;
                }
                return true;
            }
            reset(goal) {
                if (goal) {
                    this._toString = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.createInterpolator)({
                        output: [ this.getValue(), goal ]
                    });
                }
                this._value = 0;
                super.reset();
            }
        }
        const TreeContext = {
            dependencies: null
        };
        class AnimatedObject extends Animated {
            constructor(source) {
                super();
                this.source = source;
                this.setValue(source);
            }
            getValue(animated) {
                const values = {};
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(this.source, ((source, key) => {
                    if (isAnimated(source)) {
                        values[key] = source.getValue(animated);
                    } else if ((0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(source)) {
                        values[key] = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.getFluidValue)(source);
                    } else if (!animated) {
                        values[key] = source;
                    }
                }));
                return values;
            }
            setValue(source) {
                this.source = source;
                this.payload = this._makePayload(source);
            }
            reset() {
                if (this.payload) {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(this.payload, (node => node.reset()));
                }
            }
            _makePayload(source) {
                if (source) {
                    const payload = new Set;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(source, this._addToPayload, payload);
                    return Array.from(payload);
                }
            }
            _addToPayload(source) {
                if (TreeContext.dependencies && (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.hasFluidValue)(source)) {
                    TreeContext.dependencies.add(source);
                }
                const payload = getPayload(source);
                if (payload) {
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(payload, (node => this.add(node)));
                }
            }
        }
        class AnimatedArray extends AnimatedObject {
            constructor(source) {
                super(source);
            }
            static create(source) {
                return new AnimatedArray(source);
            }
            getValue() {
                return this.source.map((node => node.getValue()));
            }
            setValue(source) {
                const payload = this.getPayload();
                if (source.length == payload.length) {
                    return payload.map(((node, i) => node.setValue(source[i]))).some(Boolean);
                }
                super.setValue(source.map(makeAnimated));
                return true;
            }
        }
        function makeAnimated(value) {
            const nodeType = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isAnimatedString)(value) ? AnimatedString : AnimatedValue;
            return nodeType.create(value);
        }
        function getAnimatedType(value) {
            const parentNode = getAnimated(value);
            return parentNode ? parentNode.constructor : _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(value) ? AnimatedArray : (0, 
            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.isAnimatedString)(value) ? AnimatedString : AnimatedValue;
        }
        function _extends() {
            _extends = Object.assign || 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);
        }
        const withAnimated = (Component, host) => {
            const hasInstance = !_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(Component) || Component.prototype && Component.prototype.isReactComponent;
            return (0, react__WEBPACK_IMPORTED_MODULE_1__.forwardRef)(((givenProps, givenRef) => {
                const instanceRef = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)(null);
                const ref = hasInstance && (0, react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((value => {
                    instanceRef.current = updateRef(givenRef, value);
                }), [ givenRef ]);
                const [props, deps] = getAnimatedState(givenProps, host);
                const forceUpdate = (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useForceUpdate)();
                const callback = () => {
                    const instance = instanceRef.current;
                    if (hasInstance && !instance) {
                        return;
                    }
                    const didUpdate = instance ? host.applyAnimatedValues(instance, props.getValue(true)) : false;
                    if (didUpdate === false) {
                        forceUpdate();
                    }
                };
                const observer = new PropsObserver(callback, deps);
                const observerRef = (0, react__WEBPACK_IMPORTED_MODULE_1__.useRef)();
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)((() => {
                    observerRef.current = observer;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(deps, (dep => (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.addFluidObserver)(dep, observer)));
                    return () => {
                        if (observerRef.current) {
                            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(observerRef.current.deps, (dep => (0, 
                            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.removeFluidObserver)(dep, observerRef.current)));
                            _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.cancel(observerRef.current.update);
                        }
                    };
                }));
                (0, react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(callback, []);
                (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.useOnce)((() => () => {
                    const observer = observerRef.current;
                    (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.each)(observer.deps, (dep => (0, 
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.removeFluidObserver)(dep, observer)));
                }));
                const usedProps = host.getComponentProps(props.getValue());
                return react__WEBPACK_IMPORTED_MODULE_1__.createElement(Component, _extends({}, usedProps, {
                    ref
                }));
            }));
        };
        class PropsObserver {
            constructor(update, deps) {
                this.update = update;
                this.deps = deps;
            }
            eventObserved(event) {
                if (event.type == "change") {
                    _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.raf.write(this.update);
                }
            }
        }
        function getAnimatedState(props, host) {
            const dependencies = new Set;
            TreeContext.dependencies = dependencies;
            if (props.style) props = _extends({}, props, {
                style: host.createAnimatedStyle(props.style)
            });
            props = new AnimatedObject(props);
            TreeContext.dependencies = null;
            return [ props, dependencies ];
        }
        function updateRef(ref, value) {
            if (ref) {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(ref)) ref(value); else ref.current = value;
            }
            return value;
        }
        const cacheKey = Symbol.for("AnimatedComponent");
        const createHost = (components, {applyAnimatedValues: _applyAnimatedValues = (() => false), createAnimatedStyle: _createAnimatedStyle = (style => new AnimatedObject(style)), getComponentProps: _getComponentProps = (props => props)} = {}) => {
            const hostConfig = {
                applyAnimatedValues: _applyAnimatedValues,
                createAnimatedStyle: _createAnimatedStyle,
                getComponentProps: _getComponentProps
            };
            const animated = Component => {
                const displayName = getDisplayName(Component) || "Anonymous";
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.str(Component)) {
                    Component = animated[Component] || (animated[Component] = withAnimated(Component, hostConfig));
                } else {
                    Component = Component[cacheKey] || (Component[cacheKey] = withAnimated(Component, hostConfig));
                }
                Component.displayName = `Animated(${displayName})`;
                return Component;
            };
            (0, _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.eachProp)(components, ((Component, key) => {
                if (_react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.arr(components)) {
                    key = getDisplayName(Component);
                }
                animated[key] = animated(Component);
            }));
            return {
                animated
            };
        };
        const getDisplayName = arg => _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.str(arg) ? arg : arg && _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.str(arg.displayName) ? arg.displayName : _react_spring_shared__WEBPACK_IMPORTED_MODULE_0__.is.fun(arg) && arg.name || null;
    }, () => {}, () => {}, module => {
        "use strict";
        module.exports = ReactDOM;
    }, module => {
        var NEWTON_ITERATIONS = 4;
        var NEWTON_MIN_SLOPE = .001;
        var SUBDIVISION_PRECISION = 1e-7;
        var SUBDIVISION_MAX_ITERATIONS = 10;
        var kSplineTableSize = 11;
        var kSampleStepSize = 1 / (kSplineTableSize - 1);
        var float32ArraySupported = typeof Float32Array === "function";
        function A(aA1, aA2) {
            return 1 - 3 * aA2 + 3 * aA1;
        }
        function B(aA1, aA2) {
            return 3 * aA2 - 6 * aA1;
        }
        function C(aA1) {
            return 3 * aA1;
        }
        function calcBezier(aT, aA1, aA2) {
            return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
        }
        function getSlope(aT, aA1, aA2) {
            return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
        }
        function binarySubdivide(aX, aA, aB, mX1, mX2) {
            var currentX, currentT, i = 0;
            do {
                currentT = aA + (aB - aA) / 2;
                currentX = calcBezier(currentT, mX1, mX2) - aX;
                if (currentX > 0) {
                    aB = currentT;
                } else {
                    aA = currentT;
                }
            } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
            return currentT;
        }
        function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
            for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
                var currentSlope = getSlope(aGuessT, mX1, mX2);
                if (currentSlope === 0) {
                    return aGuessT;
                }
                var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
                aGuessT -= currentX / currentSlope;
            }
            return aGuessT;
        }
        function LinearEasing(x) {
            return x;
        }
        module.exports = function bezier(mX1, mY1, mX2, mY2) {
            if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
                throw new Error("bezier x values must be in [0, 1] range");
            }
            if (mX1 === mY1 && mX2 === mY2) {
                return LinearEasing;
            }
            var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
            for (var i = 0; i < kSplineTableSize; ++i) {
                sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
            }
            function getTForX(aX) {
                var intervalStart = 0;
                var currentSample = 1;
                var lastSample = kSplineTableSize - 1;
                for (;currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
                    intervalStart += kSampleStepSize;
                }
                --currentSample;
                var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
                var guessForT = intervalStart + dist * kSampleStepSize;
                var initialSlope = getSlope(guessForT, mX1, mX2);
                if (initialSlope >= NEWTON_MIN_SLOPE) {
                    return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
                } else if (initialSlope === 0) {
                    return guessForT;
                } else {
                    return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
                }
            }
            return function BezierEasing(x) {
                if (x === 0) {
                    return 0;
                }
                if (x === 1) {
                    return 1;
                }
                return calcBezier(getTForX(x), mY1, mY2);
            };
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            ColorPickerHooks: () => ColorPickerHooks,
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(190);
        var _components_tooltip__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(251);
        var _components_react_color_picker__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(252);
        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
        var clsx__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9);
        var _index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_6___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_6__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function ColorPickerHooks(props) {
            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_6__.useEffect)((function() {
                return LottaEvents.bind("lotta-setting-change", (function(id, colors) {
                    if (id === props.id) {
                        var options = props.options;
                        if (options.set_customizer_colors) {
                            var css = options.set_customizer_colors.selector + "{";
                            var maps = options.set_customizer_colors.maps;
                            Object.keys(maps).forEach((function(color) {
                                if (colors[color]) {
                                    if (colors[color] !== _index__WEBPACK_IMPORTED_MODULE_5__.CSS_INITIAL_VALUE && colors[color] !== "") {
                                        var selectors = maps[color];
                                        if (!Array.isArray(selectors)) {
                                            selectors = [ selectors ];
                                        }
                                        selectors.forEach((function(selector) {
                                            css += "".concat(maps[color], ": ").concat((0, _utils__WEBPACK_IMPORTED_MODULE_3__.getColorValue)(colors[color]), ";");
                                        }));
                                    }
                                }
                            }));
                            css += "}";
                            jQuery("style#" + id).remove();
                            jQuery("head").append('<style id="' + id + '">' + css + "</style>");
                        }
                    }
                }));
            }), []);
        }
        function ColorPicker(props) {
            ColorPickerHooks(props);
            var options = props.options, value = props.value, onChange = props.onChange;
            if (!options.colors) {
                return null;
            }
            var colorValues = {};
            options.colors.forEach((function(c) {
                colorValues[c.id] = value[c.id] || _index__WEBPACK_IMPORTED_MODULE_5__.CSS_INITIAL_VALUE;
            }));
            var swatches = options.swatches;
            if (!swatches && window.Lotta && window.Lotta.customizer && window.Lotta.customizer.colorPicker) {
                swatches = window.Lotta.customizer.colorPicker.swatches;
            }
            var handleColorChange = function handleColorChange(colors) {
                onChange(colors);
            };
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", {
                className: "lotta-color-picker",
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", {
                    className: "colors",
                    children: options.colors.map((function(color) {
                        var previewColor = options.computed ? (0, _utils__WEBPACK_IMPORTED_MODULE_3__.getColorValue)(colorValues[color.id] || "") : colorValues[color.id] || "";
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_0__["default"], {
                            placement: "bottom",
                            content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(_components_react_color_picker__WEBPACK_IMPORTED_MODULE_2__["default"], {
                                swatches,
                                enableAlpha: options.alpha,
                                color: previewColor,
                                onChange: function onChange(v) {
                                    handleColorChange(_objectSpread(_objectSpread({}, colorValues), {}, _defineProperty({}, color.id, v !== _index__WEBPACK_IMPORTED_MODULE_5__.CSS_INITIAL_VALUE && options.computed ? (0, 
                                    _utils__WEBPACK_IMPORTED_MODULE_3__.getColorValue)(v) : v)));
                                }
                            }),
                            children: function children(_ref) {
                                var props = _ref.props;
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", _objectSpread(_objectSpread({}, props), {}, {
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_4__["default"])({
                                        preview: true,
                                        "initial-preview": (colorValues[color.id] || "") === _index__WEBPACK_IMPORTED_MODULE_5__.CSS_INITIAL_VALUE,
                                        global: (Array.isArray(swatches) ? swatches : Object.keys(swatches)).indexOf(colorValues[color.id] || "") !== -1
                                    }),
                                    style: {
                                        color: previewColor
                                    },
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(_components_tooltip__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                        content: color.title,
                                        placement: "top",
                                        children: function children(_ref2) {
                                            var props = _ref2.props;
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", _objectSpread({
                                                className: "preview-inner"
                                            }, props));
                                        }
                                    })
                                }));
                            }
                        }, color.id);
                    }))
                })
            });
        }
        ColorPicker.renderingConfig = {
            design: "inline"
        };
        const __WEBPACK_DEFAULT_EXPORT__ = ColorPicker;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var react_popper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(191);
        var react_outside_click_handler__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        var StatePopup = function StatePopup() {
            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
                placement: "bottom",
                toggleable: true,
                arrow: true,
                offset: [ 0, 12 ]
            }, children = _ref.children, content = _ref.content, placement = _ref.placement, toggleable = _ref.toggleable, arrow = _ref.arrow, offset = _ref.offset, disableOutsideClick = _ref.disableOutsideClick;
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(false), _useState2 = _slicedToArray(_useState, 2), isOpen = _useState2[0], setIsOpen = _useState2[1];
            var _useState3 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState4 = _slicedToArray(_useState3, 2), referenceElement = _useState4[0], setReferenceElement = _useState4[1];
            var _useState5 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState6 = _slicedToArray(_useState5, 2), popperElement = _useState6[0], setPopperElement = _useState6[1];
            var _useState7 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState8 = _slicedToArray(_useState7, 2), arrowElement = _useState8[0], setArrowElement = _useState8[1];
            var _usePopper = (0, react_popper__WEBPACK_IMPORTED_MODULE_3__.usePopper)(referenceElement, popperElement, {
                placement,
                modifiers: arrow ? [ {
                    name: "offset",
                    options: {
                        offset
                    }
                }, {
                    name: "arrow",
                    options: {
                        element: arrowElement
                    }
                } ] : []
            }), styles = _usePopper.styles, attributes = _usePopper.attributes;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(react_outside_click_handler__WEBPACK_IMPORTED_MODULE_1__["default"], {
                disabled: !!disableOutsideClick,
                onOutsideClick: function onOutsideClick() {
                    if (!isOpen) {
                        return;
                    }
                    setIsOpen(false);
                },
                children: [ children({
                    setIsOpen,
                    isOpen,
                    props: {
                        ref: setReferenceElement,
                        onClick: function onClick() {
                            if (isOpen && !toggleable) {
                                return;
                            }
                            setIsOpen(!isOpen);
                        }
                    }
                }), isOpen && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)("div", _objectSpread(_objectSpread({
                    className: "lotta-popup",
                    ref: setPopperElement,
                    style: styles.popper
                }, attributes.popper), {}, {
                    children: [ content, arrow && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                        ref: setArrowElement,
                        style: styles.arrow,
                        className: "lotta-popup-arrow"
                    }) ]
                })) ]
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = StatePopup;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            usePopper: () => usePopper
        });
        var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
        var react_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(187);
        var react_dom__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react_dom__WEBPACK_IMPORTED_MODULE_1__);
        var _popperjs_core__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(194);
        var react_fast_compare__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(192);
        var react_fast_compare__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(react_fast_compare__WEBPACK_IMPORTED_MODULE_2__);
        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(193);
        var EMPTY_MODIFIERS = [];
        var usePopper = function usePopper(referenceElement, popperElement, options) {
            if (options === void 0) {
                options = {};
            }
            var prevOptions = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
            var optionsWithDefaults = {
                onFirstUpdate: options.onFirstUpdate,
                placement: options.placement || "bottom",
                strategy: options.strategy || "absolute",
                modifiers: options.modifiers || EMPTY_MODIFIERS
            };
            var _React$useState = react__WEBPACK_IMPORTED_MODULE_0__.useState({
                styles: {
                    popper: {
                        position: optionsWithDefaults.strategy,
                        left: "0",
                        top: "0"
                    },
                    arrow: {
                        position: "absolute"
                    }
                },
                attributes: {}
            }), state = _React$useState[0], setState = _React$useState[1];
            var updateStateModifier = react__WEBPACK_IMPORTED_MODULE_0__.useMemo((function() {
                return {
                    name: "updateState",
                    enabled: true,
                    phase: "write",
                    fn: function fn(_ref) {
                        var state = _ref.state;
                        var elements = Object.keys(state.elements);
                        react_dom__WEBPACK_IMPORTED_MODULE_1__.flushSync((function() {
                            setState({
                                styles: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fromEntries)(elements.map((function(element) {
                                    return [ element, state.styles[element] || {} ];
                                }))),
                                attributes: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fromEntries)(elements.map((function(element) {
                                    return [ element, state.attributes[element] ];
                                })))
                            });
                        }));
                    },
                    requires: [ "computeStyles" ]
                };
            }), []);
            var popperOptions = react__WEBPACK_IMPORTED_MODULE_0__.useMemo((function() {
                var newOptions = {
                    onFirstUpdate: optionsWithDefaults.onFirstUpdate,
                    placement: optionsWithDefaults.placement,
                    strategy: optionsWithDefaults.strategy,
                    modifiers: [].concat(optionsWithDefaults.modifiers, [ updateStateModifier, {
                        name: "applyStyles",
                        enabled: false
                    } ])
                };
                if (react_fast_compare__WEBPACK_IMPORTED_MODULE_2___default()(prevOptions.current, newOptions)) {
                    return prevOptions.current || newOptions;
                } else {
                    prevOptions.current = newOptions;
                    return newOptions;
                }
            }), [ optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier ]);
            var popperInstanceRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef();
            (0, _utils__WEBPACK_IMPORTED_MODULE_3__.useIsomorphicLayoutEffect)((function() {
                if (popperInstanceRef.current) {
                    popperInstanceRef.current.setOptions(popperOptions);
                }
            }), [ popperOptions ]);
            (0, _utils__WEBPACK_IMPORTED_MODULE_3__.useIsomorphicLayoutEffect)((function() {
                if (referenceElement == null || popperElement == null) {
                    return;
                }
                var createPopper = options.createPopper || _popperjs_core__WEBPACK_IMPORTED_MODULE_4__.createPopper;
                var popperInstance = createPopper(referenceElement, popperElement, popperOptions);
                popperInstanceRef.current = popperInstance;
                return function() {
                    popperInstance.destroy();
                    popperInstanceRef.current = null;
                };
            }), [ referenceElement, popperElement, options.createPopper ]);
            return {
                state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
                styles: state.styles,
                attributes: state.attributes,
                update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
                forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
            };
        };
    }, module => {
        var hasElementType = typeof Element !== "undefined";
        var hasMap = typeof Map === "function";
        var hasSet = typeof Set === "function";
        var hasArrayBuffer = typeof ArrayBuffer === "function" && !!ArrayBuffer.isView;
        function equal(a, b) {
            if (a === b) return true;
            if (a && b && typeof a == "object" && typeof b == "object") {
                if (a.constructor !== b.constructor) return false;
                var length, i, keys;
                if (Array.isArray(a)) {
                    length = a.length;
                    if (length != b.length) return false;
                    for (i = length; i-- !== 0; ) if (!equal(a[i], b[i])) return false;
                    return true;
                }
                var it;
                if (hasMap && a instanceof Map && b instanceof Map) {
                    if (a.size !== b.size) return false;
                    it = a.entries();
                    while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;
                    it = a.entries();
                    while (!(i = it.next()).done) if (!equal(i.value[1], b.get(i.value[0]))) return false;
                    return true;
                }
                if (hasSet && a instanceof Set && b instanceof Set) {
                    if (a.size !== b.size) return false;
                    it = a.entries();
                    while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;
                    return true;
                }
                if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
                    length = a.length;
                    if (length != b.length) return false;
                    for (i = length; i-- !== 0; ) if (a[i] !== b[i]) return false;
                    return true;
                }
                if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
                if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
                if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
                keys = Object.keys(a);
                length = keys.length;
                if (length !== Object.keys(b).length) return false;
                for (i = length; i-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
                if (hasElementType && a instanceof Element) return false;
                for (i = length; i-- !== 0; ) {
                    if ((keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) {
                        continue;
                    }
                    if (!equal(a[keys[i]], b[keys[i]])) return false;
                }
                return true;
            }
            return a !== a && b !== b;
        }
        module.exports = function isEqual(a, b) {
            try {
                return equal(a, b);
            } catch (error) {
                if ((error.message || "").match(/stack|recursion/i)) {
                    console.warn("react-fast-compare cannot handle circular refs");
                    return false;
                }
                throw error;
            }
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            fromEntries: () => fromEntries,
            safeInvoke: () => safeInvoke,
            setRef: () => setRef,
            unwrapArray: () => unwrapArray,
            useIsomorphicLayoutEffect: () => useIsomorphicLayoutEffect
        });
        var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
        var unwrapArray = function unwrapArray(arg) {
            return Array.isArray(arg) ? arg[0] : arg;
        };
        var safeInvoke = function safeInvoke(fn) {
            if (typeof fn === "function") {
                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                    args[_key - 1] = arguments[_key];
                }
                return fn.apply(void 0, args);
            }
        };
        var setRef = function setRef(ref, node) {
            if (typeof ref === "function") {
                return safeInvoke(ref, node);
            } else if (ref != null) {
                ref.current = node;
            }
        };
        var fromEntries = function fromEntries(entries) {
            return entries.reduce((function(acc, _ref) {
                var key = _ref[0], value = _ref[1];
                acc[key] = value;
                return acc;
            }), {});
        };
        var useIsomorphicLayoutEffect = typeof window !== "undefined" && window.document && window.document.createElement ? react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect : react__WEBPACK_IMPORTED_MODULE_0__.useEffect;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            applyStyles: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.applyStyles,
            arrow: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.arrow,
            computeStyles: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.computeStyles,
            createPopper: () => createPopper,
            createPopperLite: () => _popper_lite_js__WEBPACK_IMPORTED_MODULE_11__.createPopper,
            defaultModifiers: () => defaultModifiers,
            detectOverflow: () => _createPopper_js__WEBPACK_IMPORTED_MODULE_10__["default"],
            eventListeners: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.eventListeners,
            flip: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.flip,
            hide: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.hide,
            offset: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.offset,
            popperGenerator: () => _createPopper_js__WEBPACK_IMPORTED_MODULE_9__.popperGenerator,
            popperOffsets: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.popperOffsets,
            preventOverflow: () => _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__.preventOverflow
        });
        var _createPopper_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(239);
        var _createPopper_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(218);
        var _modifiers_eventListeners_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(195);
        var _modifiers_popperOffsets_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(197);
        var _modifiers_computeStyles_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(203);
        var _modifiers_applyStyles_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(212);
        var _modifiers_offset_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(213);
        var _modifiers_flip_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(214);
        var _modifiers_preventOverflow_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(233);
        var _modifiers_arrow_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(237);
        var _modifiers_hide_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(238);
        var _popper_lite_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(249);
        var _modifiers_index_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(250);
        var defaultModifiers = [ _modifiers_eventListeners_js__WEBPACK_IMPORTED_MODULE_0__["default"], _modifiers_popperOffsets_js__WEBPACK_IMPORTED_MODULE_1__["default"], _modifiers_computeStyles_js__WEBPACK_IMPORTED_MODULE_2__["default"], _modifiers_applyStyles_js__WEBPACK_IMPORTED_MODULE_3__["default"], _modifiers_offset_js__WEBPACK_IMPORTED_MODULE_4__["default"], _modifiers_flip_js__WEBPACK_IMPORTED_MODULE_5__["default"], _modifiers_preventOverflow_js__WEBPACK_IMPORTED_MODULE_6__["default"], _modifiers_arrow_js__WEBPACK_IMPORTED_MODULE_7__["default"], _modifiers_hide_js__WEBPACK_IMPORTED_MODULE_8__["default"] ];
        var createPopper = (0, _createPopper_js__WEBPACK_IMPORTED_MODULE_9__.popperGenerator)({
            defaultModifiers
        });
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _dom_utils_getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(196);
        var passive = {
            passive: true
        };
        function effect(_ref) {
            var state = _ref.state, instance = _ref.instance, options = _ref.options;
            var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
            var window = (0, _dom_utils_getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(state.elements.popper);
            var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
            if (scroll) {
                scrollParents.forEach((function(scrollParent) {
                    scrollParent.addEventListener("scroll", instance.update, passive);
                }));
            }
            if (resize) {
                window.addEventListener("resize", instance.update, passive);
            }
            return function() {
                if (scroll) {
                    scrollParents.forEach((function(scrollParent) {
                        scrollParent.removeEventListener("scroll", instance.update, passive);
                    }));
                }
                if (resize) {
                    window.removeEventListener("resize", instance.update, passive);
                }
            };
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "eventListeners",
            enabled: true,
            phase: "write",
            fn: function fn() {},
            effect,
            data: {}
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getWindow
        });
        function getWindow(node) {
            if (node == null) {
                return window;
            }
            if (node.toString() !== "[object Window]") {
                var ownerDocument = node.ownerDocument;
                return ownerDocument ? ownerDocument.defaultView || window : window;
            }
            return node;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _utils_computeOffsets_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(198);
        function popperOffsets(_ref) {
            var state = _ref.state, name = _ref.name;
            state.modifiersData[name] = (0, _utils_computeOffsets_js__WEBPACK_IMPORTED_MODULE_0__["default"])({
                reference: state.rects.reference,
                element: state.rects.popper,
                strategy: "absolute",
                placement: state.placement
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "popperOffsets",
            enabled: true,
            phase: "read",
            fn: popperOffsets,
            data: {}
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => computeOffsets
        });
        var _getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(199);
        var _getVariation_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(200);
        var _getMainAxisFromPlacement_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(202);
        var _enums_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(201);
        function computeOffsets(_ref) {
            var reference = _ref.reference, element = _ref.element, placement = _ref.placement;
            var basePlacement = placement ? (0, _getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(placement) : null;
            var variation = placement ? (0, _getVariation_js__WEBPACK_IMPORTED_MODULE_1__["default"])(placement) : null;
            var commonX = reference.x + reference.width / 2 - element.width / 2;
            var commonY = reference.y + reference.height / 2 - element.height / 2;
            var offsets;
            switch (basePlacement) {
              case _enums_js__WEBPACK_IMPORTED_MODULE_2__.top:
                offsets = {
                    x: commonX,
                    y: reference.y - element.height
                };
                break;

              case _enums_js__WEBPACK_IMPORTED_MODULE_2__.bottom:
                offsets = {
                    x: commonX,
                    y: reference.y + reference.height
                };
                break;

              case _enums_js__WEBPACK_IMPORTED_MODULE_2__.right:
                offsets = {
                    x: reference.x + reference.width,
                    y: commonY
                };
                break;

              case _enums_js__WEBPACK_IMPORTED_MODULE_2__.left:
                offsets = {
                    x: reference.x - element.width,
                    y: commonY
                };
                break;

              default:
                offsets = {
                    x: reference.x,
                    y: reference.y
                };
            }
            var mainAxis = basePlacement ? (0, _getMainAxisFromPlacement_js__WEBPACK_IMPORTED_MODULE_3__["default"])(basePlacement) : null;
            if (mainAxis != null) {
                var len = mainAxis === "y" ? "height" : "width";
                switch (variation) {
                  case _enums_js__WEBPACK_IMPORTED_MODULE_2__.start:
                    offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
                    break;

                  case _enums_js__WEBPACK_IMPORTED_MODULE_2__.end:
                    offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
                    break;

                  default:
                }
            }
            return offsets;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getBasePlacement
        });
        function getBasePlacement(placement) {
            return placement.split("-")[0];
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getVariation
        });
        function getVariation(placement) {
            return placement.split("-")[1];
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            afterMain: () => afterMain,
            afterRead: () => afterRead,
            afterWrite: () => afterWrite,
            auto: () => auto,
            basePlacements: () => basePlacements,
            beforeMain: () => beforeMain,
            beforeRead: () => beforeRead,
            beforeWrite: () => beforeWrite,
            bottom: () => bottom,
            clippingParents: () => clippingParents,
            end: () => end,
            left: () => left,
            main: () => main,
            modifierPhases: () => modifierPhases,
            placements: () => placements,
            popper: () => popper,
            read: () => read,
            reference: () => reference,
            right: () => right,
            start: () => start,
            top: () => top,
            variationPlacements: () => variationPlacements,
            viewport: () => viewport,
            write: () => write
        });
        var top = "top";
        var bottom = "bottom";
        var right = "right";
        var left = "left";
        var auto = "auto";
        var basePlacements = [ top, bottom, right, left ];
        var start = "start";
        var end = "end";
        var clippingParents = "clippingParents";
        var viewport = "viewport";
        var popper = "popper";
        var reference = "reference";
        var variationPlacements = basePlacements.reduce((function(acc, placement) {
            return acc.concat([ placement + "-" + start, placement + "-" + end ]);
        }), []);
        var placements = [].concat(basePlacements, [ auto ]).reduce((function(acc, placement) {
            return acc.concat([ placement, placement + "-" + start, placement + "-" + end ]);
        }), []);
        var beforeRead = "beforeRead";
        var read = "read";
        var afterRead = "afterRead";
        var beforeMain = "beforeMain";
        var main = "main";
        var afterMain = "afterMain";
        var beforeWrite = "beforeWrite";
        var write = "write";
        var afterWrite = "afterWrite";
        var modifierPhases = [ beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite ];
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getMainAxisFromPlacement
        });
        function getMainAxisFromPlacement(placement) {
            return [ "top", "bottom" ].indexOf(placement) >= 0 ? "x" : "y";
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__,
            mapToStyles: () => mapToStyles
        });
        var _enums_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(201);
        var _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(205);
        var _dom_utils_getWindow_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(196);
        var _dom_utils_getDocumentElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(210);
        var _dom_utils_getComputedStyle_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(207);
        var _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(199);
        var _utils_getVariation_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(200);
        var _utils_math_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(204);
        var unsetSides = {
            top: "auto",
            right: "auto",
            bottom: "auto",
            left: "auto"
        };
        function roundOffsetsByDPR(_ref) {
            var x = _ref.x, y = _ref.y;
            var win = window;
            var dpr = win.devicePixelRatio || 1;
            return {
                x: (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_0__.round)(x * dpr) / dpr || 0,
                y: (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_0__.round)(y * dpr) / dpr || 0
            };
        }
        function mapToStyles(_ref2) {
            var _Object$assign2;
            var popper = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
            var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
            var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
                x,
                y
            }) : {
                x,
                y
            };
            x = _ref3.x;
            y = _ref3.y;
            var hasX = offsets.hasOwnProperty("x");
            var hasY = offsets.hasOwnProperty("y");
            var sideX = _enums_js__WEBPACK_IMPORTED_MODULE_1__.left;
            var sideY = _enums_js__WEBPACK_IMPORTED_MODULE_1__.top;
            var win = window;
            if (adaptive) {
                var offsetParent = (0, _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_2__["default"])(popper);
                var heightProp = "clientHeight";
                var widthProp = "clientWidth";
                if (offsetParent === (0, _dom_utils_getWindow_js__WEBPACK_IMPORTED_MODULE_3__["default"])(popper)) {
                    offsetParent = (0, _dom_utils_getDocumentElement_js__WEBPACK_IMPORTED_MODULE_4__["default"])(popper);
                    if ((0, _dom_utils_getComputedStyle_js__WEBPACK_IMPORTED_MODULE_5__["default"])(offsetParent).position !== "static" && position === "absolute") {
                        heightProp = "scrollHeight";
                        widthProp = "scrollWidth";
                    }
                }
                offsetParent = offsetParent;
                if (placement === _enums_js__WEBPACK_IMPORTED_MODULE_1__.top || (placement === _enums_js__WEBPACK_IMPORTED_MODULE_1__.left || placement === _enums_js__WEBPACK_IMPORTED_MODULE_1__.right) && variation === _enums_js__WEBPACK_IMPORTED_MODULE_1__.end) {
                    sideY = _enums_js__WEBPACK_IMPORTED_MODULE_1__.bottom;
                    var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp];
                    y -= offsetY - popperRect.height;
                    y *= gpuAcceleration ? 1 : -1;
                }
                if (placement === _enums_js__WEBPACK_IMPORTED_MODULE_1__.left || (placement === _enums_js__WEBPACK_IMPORTED_MODULE_1__.top || placement === _enums_js__WEBPACK_IMPORTED_MODULE_1__.bottom) && variation === _enums_js__WEBPACK_IMPORTED_MODULE_1__.end) {
                    sideX = _enums_js__WEBPACK_IMPORTED_MODULE_1__.right;
                    var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp];
                    x -= offsetX - popperRect.width;
                    x *= gpuAcceleration ? 1 : -1;
                }
            }
            var commonStyles = Object.assign({
                position
            }, adaptive && unsetSides);
            var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
                x,
                y
            }) : {
                x,
                y
            };
            x = _ref4.x;
            y = _ref4.y;
            if (gpuAcceleration) {
                var _Object$assign;
                return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", 
                _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", 
                _Object$assign));
            }
            return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", 
            _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
        }
        function computeStyles(_ref5) {
            var state = _ref5.state, options = _ref5.options;
            var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
            if (true) {
                var transitionProperty = (0, _dom_utils_getComputedStyle_js__WEBPACK_IMPORTED_MODULE_5__["default"])(state.elements.popper).transitionProperty || "";
                if (adaptive && [ "transform", "top", "right", "bottom", "left" ].some((function(property) {
                    return transitionProperty.indexOf(property) >= 0;
                }))) {
                    console.warn([ "Popper: Detected CSS transitions on at least one of the following", 'CSS properties: "transform", "top", "right", "bottom", "left".', "\n\n", 'Disable the "computeStyles" modifier\'s `adaptive` option to allow', "for smooth transitions, or remove these properties from the CSS", "transition declaration on the popper element if only transitioning", "opacity or background-color for example.", "\n\n", "We recommend using the popper element as a wrapper around an inner", "element that can have any CSS property transitioned for animations." ].join(" "));
                }
            }
            var commonStyles = {
                placement: (0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_6__["default"])(state.placement),
                variation: (0, _utils_getVariation_js__WEBPACK_IMPORTED_MODULE_7__["default"])(state.placement),
                popper: state.elements.popper,
                popperRect: state.rects.popper,
                gpuAcceleration,
                isFixed: state.options.strategy === "fixed"
            };
            if (state.modifiersData.popperOffsets != null) {
                state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
                    offsets: state.modifiersData.popperOffsets,
                    position: state.options.strategy,
                    adaptive,
                    roundOffsets
                })));
            }
            if (state.modifiersData.arrow != null) {
                state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
                    offsets: state.modifiersData.arrow,
                    position: "absolute",
                    adaptive: false,
                    roundOffsets
                })));
            }
            state.attributes.popper = Object.assign({}, state.attributes.popper, {
                "data-popper-placement": state.placement
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "computeStyles",
            enabled: true,
            phase: "beforeWrite",
            fn: computeStyles,
            data: {}
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            max: () => max,
            min: () => min,
            round: () => round
        });
        var max = Math.max;
        var min = Math.min;
        var round = Math.round;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getOffsetParent
        });
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(196);
        var _getNodeName_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(209);
        var _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(207);
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
        var _isTableElement_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(211);
        var _getParentNode_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(208);
        function getTrueOffsetParent(element) {
            if (!(0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(element) || (0, 
            _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element).position === "fixed") {
                return null;
            }
            return element.offsetParent;
        }
        function getContainingBlock(element) {
            var isFirefox = navigator.userAgent.toLowerCase().indexOf("firefox") !== -1;
            var isIE = navigator.userAgent.indexOf("Trident") !== -1;
            if (isIE && (0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(element)) {
                var elementCss = (0, _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element);
                if (elementCss.position === "fixed") {
                    return null;
                }
            }
            var currentNode = (0, _getParentNode_js__WEBPACK_IMPORTED_MODULE_2__["default"])(element);
            if ((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isShadowRoot)(currentNode)) {
                currentNode = currentNode.host;
            }
            while ((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(currentNode) && [ "html", "body" ].indexOf((0, 
            _getNodeName_js__WEBPACK_IMPORTED_MODULE_3__["default"])(currentNode)) < 0) {
                var css = (0, _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(currentNode);
                if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || [ "transform", "perspective" ].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
                    return currentNode;
                } else {
                    currentNode = currentNode.parentNode;
                }
            }
            return null;
        }
        function getOffsetParent(element) {
            var window = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_4__["default"])(element);
            var offsetParent = getTrueOffsetParent(element);
            while (offsetParent && (0, _isTableElement_js__WEBPACK_IMPORTED_MODULE_5__["default"])(offsetParent) && (0, 
            _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(offsetParent).position === "static") {
                offsetParent = getTrueOffsetParent(offsetParent);
            }
            if (offsetParent && ((0, _getNodeName_js__WEBPACK_IMPORTED_MODULE_3__["default"])(offsetParent) === "html" || (0, 
            _getNodeName_js__WEBPACK_IMPORTED_MODULE_3__["default"])(offsetParent) === "body" && (0, 
            _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(offsetParent).position === "static")) {
                return window;
            }
            return offsetParent || getContainingBlock(element) || window;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            isElement: () => isElement,
            isHTMLElement: () => isHTMLElement,
            isShadowRoot: () => isShadowRoot
        });
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(196);
        function isElement(node) {
            var OwnElement = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(node).Element;
            return node instanceof OwnElement || node instanceof Element;
        }
        function isHTMLElement(node) {
            var OwnElement = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(node).HTMLElement;
            return node instanceof OwnElement || node instanceof HTMLElement;
        }
        function isShadowRoot(node) {
            if (typeof ShadowRoot === "undefined") {
                return false;
            }
            var OwnElement = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(node).ShadowRoot;
            return node instanceof OwnElement || node instanceof ShadowRoot;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getComputedStyle
        });
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(196);
        function getComputedStyle(element) {
            return (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element).getComputedStyle(element);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getParentNode
        });
        var _getNodeName_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(209);
        var _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(210);
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(206);
        function getParentNode(element) {
            if ((0, _getNodeName_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element) === "html") {
                return element;
            }
            return element.assignedSlot || element.parentNode || ((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__.isShadowRoot)(element) ? element.host : null) || (0, 
            _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_2__["default"])(element);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getNodeName
        });
        function getNodeName(element) {
            return element ? (element.nodeName || "").toLowerCase() : null;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getDocumentElement
        });
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
        function getDocumentElement(element) {
            return (((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isElement)(element) ? element.ownerDocument : element.document) || window.document).documentElement;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => isTableElement
        });
        var _getNodeName_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(209);
        function isTableElement(element) {
            return [ "table", "td", "th" ].indexOf((0, _getNodeName_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element)) >= 0;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _dom_utils_getNodeName_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(209);
        var _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
        function applyStyles(_ref) {
            var state = _ref.state;
            Object.keys(state.elements).forEach((function(name) {
                var style = state.styles[name] || {};
                var attributes = state.attributes[name] || {};
                var element = state.elements[name];
                if (!(0, _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(element) || !(0, 
                _dom_utils_getNodeName_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element)) {
                    return;
                }
                Object.assign(element.style, style);
                Object.keys(attributes).forEach((function(name) {
                    var value = attributes[name];
                    if (value === false) {
                        element.removeAttribute(name);
                    } else {
                        element.setAttribute(name, value === true ? "" : value);
                    }
                }));
            }));
        }
        function effect(_ref2) {
            var state = _ref2.state;
            var initialStyles = {
                popper: {
                    position: state.options.strategy,
                    left: "0",
                    top: "0",
                    margin: "0"
                },
                arrow: {
                    position: "absolute"
                },
                reference: {}
            };
            Object.assign(state.elements.popper.style, initialStyles.popper);
            state.styles = initialStyles;
            if (state.elements.arrow) {
                Object.assign(state.elements.arrow.style, initialStyles.arrow);
            }
            return function() {
                Object.keys(state.elements).forEach((function(name) {
                    var element = state.elements[name];
                    var attributes = state.attributes[name] || {};
                    var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
                    var style = styleProperties.reduce((function(style, property) {
                        style[property] = "";
                        return style;
                    }), {});
                    if (!(0, _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(element) || !(0, 
                    _dom_utils_getNodeName_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element)) {
                        return;
                    }
                    Object.assign(element.style, style);
                    Object.keys(attributes).forEach((function(attribute) {
                        element.removeAttribute(attribute);
                    }));
                }));
            };
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "applyStyles",
            enabled: true,
            phase: "write",
            fn: applyStyles,
            effect,
            requires: [ "computeStyles" ]
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__,
            distanceAndSkiddingToXY: () => distanceAndSkiddingToXY
        });
        var _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(199);
        var _enums_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(201);
        function distanceAndSkiddingToXY(placement, rects, offset) {
            var basePlacement = (0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(placement);
            var invertDistance = [ _enums_js__WEBPACK_IMPORTED_MODULE_1__.left, _enums_js__WEBPACK_IMPORTED_MODULE_1__.top ].indexOf(basePlacement) >= 0 ? -1 : 1;
            var _ref = typeof offset === "function" ? offset(Object.assign({}, rects, {
                placement
            })) : offset, skidding = _ref[0], distance = _ref[1];
            skidding = skidding || 0;
            distance = (distance || 0) * invertDistance;
            return [ _enums_js__WEBPACK_IMPORTED_MODULE_1__.left, _enums_js__WEBPACK_IMPORTED_MODULE_1__.right ].indexOf(basePlacement) >= 0 ? {
                x: distance,
                y: skidding
            } : {
                x: skidding,
                y: distance
            };
        }
        function offset(_ref2) {
            var state = _ref2.state, options = _ref2.options, name = _ref2.name;
            var _options$offset = options.offset, offset = _options$offset === void 0 ? [ 0, 0 ] : _options$offset;
            var data = _enums_js__WEBPACK_IMPORTED_MODULE_1__.placements.reduce((function(acc, placement) {
                acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
                return acc;
            }), {});
            var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
            if (state.modifiersData.popperOffsets != null) {
                state.modifiersData.popperOffsets.x += x;
                state.modifiersData.popperOffsets.y += y;
            }
            state.modifiersData[name] = data;
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "offset",
            enabled: true,
            phase: "main",
            requires: [ "popperOffsets" ],
            fn: offset
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _utils_getOppositePlacement_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(215);
        var _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(199);
        var _utils_getOppositeVariationPlacement_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(216);
        var _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(218);
        var _utils_computeAutoPlacement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(217);
        var _enums_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(201);
        var _utils_getVariation_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(200);
        function getExpandedFallbackPlacements(placement) {
            if ((0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(placement) === _enums_js__WEBPACK_IMPORTED_MODULE_1__.auto) {
                return [];
            }
            var oppositePlacement = (0, _utils_getOppositePlacement_js__WEBPACK_IMPORTED_MODULE_2__["default"])(placement);
            return [ (0, _utils_getOppositeVariationPlacement_js__WEBPACK_IMPORTED_MODULE_3__["default"])(placement), oppositePlacement, (0, 
            _utils_getOppositeVariationPlacement_js__WEBPACK_IMPORTED_MODULE_3__["default"])(oppositePlacement) ];
        }
        function flip(_ref) {
            var state = _ref.state, options = _ref.options, name = _ref.name;
            if (state.modifiersData[name]._skip) {
                return;
            }
            var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
            var preferredPlacement = state.options.placement;
            var basePlacement = (0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(preferredPlacement);
            var isBasePlacement = basePlacement === preferredPlacement;
            var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [ (0, 
            _utils_getOppositePlacement_js__WEBPACK_IMPORTED_MODULE_2__["default"])(preferredPlacement) ] : getExpandedFallbackPlacements(preferredPlacement));
            var placements = [ preferredPlacement ].concat(fallbackPlacements).reduce((function(acc, placement) {
                return acc.concat((0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(placement) === _enums_js__WEBPACK_IMPORTED_MODULE_1__.auto ? (0, 
                _utils_computeAutoPlacement_js__WEBPACK_IMPORTED_MODULE_4__["default"])(state, {
                    placement,
                    boundary,
                    rootBoundary,
                    padding,
                    flipVariations,
                    allowedAutoPlacements
                }) : placement);
            }), []);
            var referenceRect = state.rects.reference;
            var popperRect = state.rects.popper;
            var checksMap = new Map;
            var makeFallbackChecks = true;
            var firstFittingPlacement = placements[0];
            for (var i = 0; i < placements.length; i++) {
                var placement = placements[i];
                var _basePlacement = (0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(placement);
                var isStartVariation = (0, _utils_getVariation_js__WEBPACK_IMPORTED_MODULE_5__["default"])(placement) === _enums_js__WEBPACK_IMPORTED_MODULE_1__.start;
                var isVertical = [ _enums_js__WEBPACK_IMPORTED_MODULE_1__.top, _enums_js__WEBPACK_IMPORTED_MODULE_1__.bottom ].indexOf(_basePlacement) >= 0;
                var len = isVertical ? "width" : "height";
                var overflow = (0, _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_6__["default"])(state, {
                    placement,
                    boundary,
                    rootBoundary,
                    altBoundary,
                    padding
                });
                var mainVariationSide = isVertical ? isStartVariation ? _enums_js__WEBPACK_IMPORTED_MODULE_1__.right : _enums_js__WEBPACK_IMPORTED_MODULE_1__.left : isStartVariation ? _enums_js__WEBPACK_IMPORTED_MODULE_1__.bottom : _enums_js__WEBPACK_IMPORTED_MODULE_1__.top;
                if (referenceRect[len] > popperRect[len]) {
                    mainVariationSide = (0, _utils_getOppositePlacement_js__WEBPACK_IMPORTED_MODULE_2__["default"])(mainVariationSide);
                }
                var altVariationSide = (0, _utils_getOppositePlacement_js__WEBPACK_IMPORTED_MODULE_2__["default"])(mainVariationSide);
                var checks = [];
                if (checkMainAxis) {
                    checks.push(overflow[_basePlacement] <= 0);
                }
                if (checkAltAxis) {
                    checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
                }
                if (checks.every((function(check) {
                    return check;
                }))) {
                    firstFittingPlacement = placement;
                    makeFallbackChecks = false;
                    break;
                }
                checksMap.set(placement, checks);
            }
            if (makeFallbackChecks) {
                var numberOfChecks = flipVariations ? 3 : 1;
                var _loop = function _loop(_i) {
                    var fittingPlacement = placements.find((function(placement) {
                        var checks = checksMap.get(placement);
                        if (checks) {
                            return checks.slice(0, _i).every((function(check) {
                                return check;
                            }));
                        }
                    }));
                    if (fittingPlacement) {
                        firstFittingPlacement = fittingPlacement;
                        return "break";
                    }
                };
                for (var _i = numberOfChecks; _i > 0; _i--) {
                    var _ret = _loop(_i);
                    if (_ret === "break") break;
                }
            }
            if (state.placement !== firstFittingPlacement) {
                state.modifiersData[name]._skip = true;
                state.placement = firstFittingPlacement;
                state.reset = true;
            }
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "flip",
            enabled: true,
            phase: "main",
            fn: flip,
            requiresIfExists: [ "offset" ],
            data: {
                _skip: false
            }
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getOppositePlacement
        });
        var hash = {
            left: "right",
            right: "left",
            bottom: "top",
            top: "bottom"
        };
        function getOppositePlacement(placement) {
            return placement.replace(/left|right|bottom|top/g, (function(matched) {
                return hash[matched];
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getOppositeVariationPlacement
        });
        var hash = {
            start: "end",
            end: "start"
        };
        function getOppositeVariationPlacement(placement) {
            return placement.replace(/start|end/g, (function(matched) {
                return hash[matched];
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => computeAutoPlacement
        });
        var _getVariation_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(200);
        var _enums_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(201);
        var _detectOverflow_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(218);
        var _getBasePlacement_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(199);
        function computeAutoPlacement(state, options) {
            if (options === void 0) {
                options = {};
            }
            var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? _enums_js__WEBPACK_IMPORTED_MODULE_0__.placements : _options$allowedAutoP;
            var variation = (0, _getVariation_js__WEBPACK_IMPORTED_MODULE_1__["default"])(placement);
            var placements = variation ? flipVariations ? _enums_js__WEBPACK_IMPORTED_MODULE_0__.variationPlacements : _enums_js__WEBPACK_IMPORTED_MODULE_0__.variationPlacements.filter((function(placement) {
                return (0, _getVariation_js__WEBPACK_IMPORTED_MODULE_1__["default"])(placement) === variation;
            })) : _enums_js__WEBPACK_IMPORTED_MODULE_0__.basePlacements;
            var allowedPlacements = placements.filter((function(placement) {
                return allowedAutoPlacements.indexOf(placement) >= 0;
            }));
            if (allowedPlacements.length === 0) {
                allowedPlacements = placements;
                if (true) {
                    console.error([ "Popper: The `allowedAutoPlacements` option did not allow any", "placements. Ensure the `placement` option matches the variation", "of the allowed placements.", 'For example, "auto" cannot be used to allow "bottom-start".', 'Use "auto-start" instead.' ].join(" "));
                }
            }
            var overflows = allowedPlacements.reduce((function(acc, placement) {
                acc[placement] = (0, _detectOverflow_js__WEBPACK_IMPORTED_MODULE_2__["default"])(state, {
                    placement,
                    boundary,
                    rootBoundary,
                    padding
                })[(0, _getBasePlacement_js__WEBPACK_IMPORTED_MODULE_3__["default"])(placement)];
                return acc;
            }), {});
            return Object.keys(overflows).sort((function(a, b) {
                return overflows[a] - overflows[b];
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => detectOverflow
        });
        var _dom_utils_getClippingRect_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(222);
        var _dom_utils_getDocumentElement_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(210);
        var _dom_utils_getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(223);
        var _computeOffsets_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(198);
        var _rectToClientRect_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(224);
        var _enums_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(201);
        var _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(206);
        var _mergePaddingObject_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(219);
        var _expandToHashMap_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(221);
        function detectOverflow(state, options) {
            if (options === void 0) {
                options = {};
            }
            var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? _enums_js__WEBPACK_IMPORTED_MODULE_0__.clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? _enums_js__WEBPACK_IMPORTED_MODULE_0__.viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? _enums_js__WEBPACK_IMPORTED_MODULE_0__.popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
            var paddingObject = (0, _mergePaddingObject_js__WEBPACK_IMPORTED_MODULE_1__["default"])(typeof padding !== "number" ? padding : (0, 
            _expandToHashMap_js__WEBPACK_IMPORTED_MODULE_2__["default"])(padding, _enums_js__WEBPACK_IMPORTED_MODULE_0__.basePlacements));
            var altContext = elementContext === _enums_js__WEBPACK_IMPORTED_MODULE_0__.popper ? _enums_js__WEBPACK_IMPORTED_MODULE_0__.reference : _enums_js__WEBPACK_IMPORTED_MODULE_0__.popper;
            var popperRect = state.rects.popper;
            var element = state.elements[altBoundary ? altContext : elementContext];
            var clippingClientRect = (0, _dom_utils_getClippingRect_js__WEBPACK_IMPORTED_MODULE_3__["default"])((0, 
            _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_4__.isElement)(element) ? element : element.contextElement || (0, 
            _dom_utils_getDocumentElement_js__WEBPACK_IMPORTED_MODULE_5__["default"])(state.elements.popper), boundary, rootBoundary);
            var referenceClientRect = (0, _dom_utils_getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_6__["default"])(state.elements.reference);
            var popperOffsets = (0, _computeOffsets_js__WEBPACK_IMPORTED_MODULE_7__["default"])({
                reference: referenceClientRect,
                element: popperRect,
                strategy: "absolute",
                placement
            });
            var popperClientRect = (0, _rectToClientRect_js__WEBPACK_IMPORTED_MODULE_8__["default"])(Object.assign({}, popperRect, popperOffsets));
            var elementClientRect = elementContext === _enums_js__WEBPACK_IMPORTED_MODULE_0__.popper ? popperClientRect : referenceClientRect;
            var overflowOffsets = {
                top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
                bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
                left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
                right: elementClientRect.right - clippingClientRect.right + paddingObject.right
            };
            var offsetData = state.modifiersData.offset;
            if (elementContext === _enums_js__WEBPACK_IMPORTED_MODULE_0__.popper && offsetData) {
                var offset = offsetData[placement];
                Object.keys(overflowOffsets).forEach((function(key) {
                    var multiply = [ _enums_js__WEBPACK_IMPORTED_MODULE_0__.right, _enums_js__WEBPACK_IMPORTED_MODULE_0__.bottom ].indexOf(key) >= 0 ? 1 : -1;
                    var axis = [ _enums_js__WEBPACK_IMPORTED_MODULE_0__.top, _enums_js__WEBPACK_IMPORTED_MODULE_0__.bottom ].indexOf(key) >= 0 ? "y" : "x";
                    overflowOffsets[key] += offset[axis] * multiply;
                }));
            }
            return overflowOffsets;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => mergePaddingObject
        });
        var _getFreshSideObject_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(220);
        function mergePaddingObject(paddingObject) {
            return Object.assign({}, (0, _getFreshSideObject_js__WEBPACK_IMPORTED_MODULE_0__["default"])(), paddingObject);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getFreshSideObject
        });
        function getFreshSideObject() {
            return {
                top: 0,
                right: 0,
                bottom: 0,
                left: 0
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => expandToHashMap
        });
        function expandToHashMap(value, keys) {
            return keys.reduce((function(hashMap, key) {
                hashMap[key] = value;
                return hashMap;
            }), {});
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getClippingRect
        });
        var _enums_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(201);
        var _getViewportRect_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(225);
        var _getDocumentRect_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(228);
        var _listScrollParents_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(229);
        var _getOffsetParent_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(205);
        var _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(210);
        var _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(207);
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(206);
        var _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(223);
        var _getParentNode_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(208);
        var _contains_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(232);
        var _getNodeName_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(209);
        var _utils_rectToClientRect_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(224);
        var _utils_math_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(204);
        function getInnerBoundingClientRect(element) {
            var rect = (0, _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element);
            rect.top = rect.top + element.clientTop;
            rect.left = rect.left + element.clientLeft;
            rect.bottom = rect.top + element.clientHeight;
            rect.right = rect.left + element.clientWidth;
            rect.width = element.clientWidth;
            rect.height = element.clientHeight;
            rect.x = rect.left;
            rect.y = rect.top;
            return rect;
        }
        function getClientRectFromMixedType(element, clippingParent) {
            return clippingParent === _enums_js__WEBPACK_IMPORTED_MODULE_1__.viewport ? (0, 
            _utils_rectToClientRect_js__WEBPACK_IMPORTED_MODULE_2__["default"])((0, _getViewportRect_js__WEBPACK_IMPORTED_MODULE_3__["default"])(element)) : (0, 
            _instanceOf_js__WEBPACK_IMPORTED_MODULE_4__.isElement)(clippingParent) ? getInnerBoundingClientRect(clippingParent) : (0, 
            _utils_rectToClientRect_js__WEBPACK_IMPORTED_MODULE_2__["default"])((0, _getDocumentRect_js__WEBPACK_IMPORTED_MODULE_5__["default"])((0, 
            _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_6__["default"])(element)));
        }
        function getClippingParents(element) {
            var clippingParents = (0, _listScrollParents_js__WEBPACK_IMPORTED_MODULE_7__["default"])((0, 
            _getParentNode_js__WEBPACK_IMPORTED_MODULE_8__["default"])(element));
            var canEscapeClipping = [ "absolute", "fixed" ].indexOf((0, _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_9__["default"])(element).position) >= 0;
            var clipperElement = canEscapeClipping && (0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_4__.isHTMLElement)(element) ? (0, 
            _getOffsetParent_js__WEBPACK_IMPORTED_MODULE_10__["default"])(element) : element;
            if (!(0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_4__.isElement)(clipperElement)) {
                return [];
            }
            return clippingParents.filter((function(clippingParent) {
                return (0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_4__.isElement)(clippingParent) && (0, 
                _contains_js__WEBPACK_IMPORTED_MODULE_11__["default"])(clippingParent, clipperElement) && (0, 
                _getNodeName_js__WEBPACK_IMPORTED_MODULE_12__["default"])(clippingParent) !== "body";
            }));
        }
        function getClippingRect(element, boundary, rootBoundary) {
            var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
            var clippingParents = [].concat(mainClippingParents, [ rootBoundary ]);
            var firstClippingParent = clippingParents[0];
            var clippingRect = clippingParents.reduce((function(accRect, clippingParent) {
                var rect = getClientRectFromMixedType(element, clippingParent);
                accRect.top = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_13__.max)(rect.top, accRect.top);
                accRect.right = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_13__.min)(rect.right, accRect.right);
                accRect.bottom = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_13__.min)(rect.bottom, accRect.bottom);
                accRect.left = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_13__.max)(rect.left, accRect.left);
                return accRect;
            }), getClientRectFromMixedType(element, firstClippingParent));
            clippingRect.width = clippingRect.right - clippingRect.left;
            clippingRect.height = clippingRect.bottom - clippingRect.top;
            clippingRect.x = clippingRect.left;
            clippingRect.y = clippingRect.top;
            return clippingRect;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getBoundingClientRect
        });
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
        var _utils_math_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(204);
        function getBoundingClientRect(element, includeScale) {
            if (includeScale === void 0) {
                includeScale = false;
            }
            var rect = element.getBoundingClientRect();
            var scaleX = 1;
            var scaleY = 1;
            if ((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(element) && includeScale) {
                var offsetHeight = element.offsetHeight;
                var offsetWidth = element.offsetWidth;
                if (offsetWidth > 0) {
                    scaleX = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_1__.round)(rect.width) / offsetWidth || 1;
                }
                if (offsetHeight > 0) {
                    scaleY = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_1__.round)(rect.height) / offsetHeight || 1;
                }
            }
            return {
                width: rect.width / scaleX,
                height: rect.height / scaleY,
                top: rect.top / scaleY,
                right: rect.right / scaleX,
                bottom: rect.bottom / scaleY,
                left: rect.left / scaleX,
                x: rect.left / scaleX,
                y: rect.top / scaleY
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => rectToClientRect
        });
        function rectToClientRect(rect) {
            return Object.assign({}, rect, {
                left: rect.x,
                top: rect.y,
                right: rect.x + rect.width,
                bottom: rect.y + rect.height
            });
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getViewportRect
        });
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(196);
        var _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(210);
        var _getWindowScrollBarX_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(226);
        function getViewportRect(element) {
            var win = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element);
            var html = (0, _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element);
            var visualViewport = win.visualViewport;
            var width = html.clientWidth;
            var height = html.clientHeight;
            var x = 0;
            var y = 0;
            if (visualViewport) {
                width = visualViewport.width;
                height = visualViewport.height;
                if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
                    x = visualViewport.offsetLeft;
                    y = visualViewport.offsetTop;
                }
            }
            return {
                width,
                height,
                x: x + (0, _getWindowScrollBarX_js__WEBPACK_IMPORTED_MODULE_2__["default"])(element),
                y
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getWindowScrollBarX
        });
        var _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(223);
        var _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(210);
        var _getWindowScroll_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(227);
        function getWindowScrollBarX(element) {
            return (0, _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_0__["default"])((0, 
            _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element)).left + (0, 
            _getWindowScroll_js__WEBPACK_IMPORTED_MODULE_2__["default"])(element).scrollLeft;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getWindowScroll
        });
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(196);
        function getWindowScroll(node) {
            var win = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(node);
            var scrollLeft = win.pageXOffset;
            var scrollTop = win.pageYOffset;
            return {
                scrollLeft,
                scrollTop
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getDocumentRect
        });
        var _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(210);
        var _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(207);
        var _getWindowScrollBarX_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(226);
        var _getWindowScroll_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(227);
        var _utils_math_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(204);
        function getDocumentRect(element) {
            var _element$ownerDocumen;
            var html = (0, _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element);
            var winScroll = (0, _getWindowScroll_js__WEBPACK_IMPORTED_MODULE_1__["default"])(element);
            var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
            var width = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_2__.max)(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
            var height = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_2__.max)(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
            var x = -winScroll.scrollLeft + (0, _getWindowScrollBarX_js__WEBPACK_IMPORTED_MODULE_3__["default"])(element);
            var y = -winScroll.scrollTop;
            if ((0, _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_4__["default"])(body || html).direction === "rtl") {
                x += (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_2__.max)(html.clientWidth, body ? body.clientWidth : 0) - width;
            }
            return {
                width,
                height,
                x,
                y
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => listScrollParents
        });
        var _getScrollParent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(230);
        var _getParentNode_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(208);
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(196);
        var _isScrollParent_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(231);
        function listScrollParents(element, list) {
            var _element$ownerDocumen;
            if (list === void 0) {
                list = [];
            }
            var scrollParent = (0, _getScrollParent_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element);
            var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
            var win = (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_1__["default"])(scrollParent);
            var target = isBody ? [ win ].concat(win.visualViewport || [], (0, _isScrollParent_js__WEBPACK_IMPORTED_MODULE_2__["default"])(scrollParent) ? scrollParent : []) : scrollParent;
            var updatedList = list.concat(target);
            return isBody ? updatedList : updatedList.concat(listScrollParents((0, _getParentNode_js__WEBPACK_IMPORTED_MODULE_3__["default"])(target)));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getScrollParent
        });
        var _getParentNode_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(208);
        var _isScrollParent_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(231);
        var _getNodeName_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(209);
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(206);
        function getScrollParent(node) {
            if ([ "html", "body", "#document" ].indexOf((0, _getNodeName_js__WEBPACK_IMPORTED_MODULE_0__["default"])(node)) >= 0) {
                return node.ownerDocument.body;
            }
            if ((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(node) && (0, 
            _isScrollParent_js__WEBPACK_IMPORTED_MODULE_2__["default"])(node)) {
                return node;
            }
            return getScrollParent((0, _getParentNode_js__WEBPACK_IMPORTED_MODULE_3__["default"])(node));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => isScrollParent
        });
        var _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(207);
        function isScrollParent(element) {
            var _getComputedStyle = (0, _getComputedStyle_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
            return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => contains
        });
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
        function contains(parent, child) {
            var rootNode = child.getRootNode && child.getRootNode();
            if (parent.contains(child)) {
                return true;
            } else if (rootNode && (0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isShadowRoot)(rootNode)) {
                var next = child;
                do {
                    if (next && parent.isSameNode(next)) {
                        return true;
                    }
                    next = next.parentNode || next.host;
                } while (next);
            }
            return false;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _enums_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(201);
        var _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(199);
        var _utils_getMainAxisFromPlacement_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(202);
        var _utils_getAltAxis_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(234);
        var _utils_within_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(236);
        var _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(235);
        var _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(205);
        var _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(218);
        var _utils_getVariation_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(200);
        var _utils_getFreshSideObject_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(220);
        var _utils_math_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(204);
        function preventOverflow(_ref) {
            var state = _ref.state, options = _ref.options, name = _ref.name;
            var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
            var overflow = (0, _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(state, {
                boundary,
                rootBoundary,
                padding,
                altBoundary
            });
            var basePlacement = (0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_1__["default"])(state.placement);
            var variation = (0, _utils_getVariation_js__WEBPACK_IMPORTED_MODULE_2__["default"])(state.placement);
            var isBasePlacement = !variation;
            var mainAxis = (0, _utils_getMainAxisFromPlacement_js__WEBPACK_IMPORTED_MODULE_3__["default"])(basePlacement);
            var altAxis = (0, _utils_getAltAxis_js__WEBPACK_IMPORTED_MODULE_4__["default"])(mainAxis);
            var popperOffsets = state.modifiersData.popperOffsets;
            var referenceRect = state.rects.reference;
            var popperRect = state.rects.popper;
            var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
                placement: state.placement
            })) : tetherOffset;
            var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
                mainAxis: tetherOffsetValue,
                altAxis: tetherOffsetValue
            } : Object.assign({
                mainAxis: 0,
                altAxis: 0
            }, tetherOffsetValue);
            var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
            var data = {
                x: 0,
                y: 0
            };
            if (!popperOffsets) {
                return;
            }
            if (checkMainAxis) {
                var _offsetModifierState$;
                var mainSide = mainAxis === "y" ? _enums_js__WEBPACK_IMPORTED_MODULE_5__.top : _enums_js__WEBPACK_IMPORTED_MODULE_5__.left;
                var altSide = mainAxis === "y" ? _enums_js__WEBPACK_IMPORTED_MODULE_5__.bottom : _enums_js__WEBPACK_IMPORTED_MODULE_5__.right;
                var len = mainAxis === "y" ? "height" : "width";
                var offset = popperOffsets[mainAxis];
                var min = offset + overflow[mainSide];
                var max = offset - overflow[altSide];
                var additive = tether ? -popperRect[len] / 2 : 0;
                var minLen = variation === _enums_js__WEBPACK_IMPORTED_MODULE_5__.start ? referenceRect[len] : popperRect[len];
                var maxLen = variation === _enums_js__WEBPACK_IMPORTED_MODULE_5__.start ? -popperRect[len] : -referenceRect[len];
                var arrowElement = state.elements.arrow;
                var arrowRect = tether && arrowElement ? (0, _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_6__["default"])(arrowElement) : {
                    width: 0,
                    height: 0
                };
                var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : (0, 
                _utils_getFreshSideObject_js__WEBPACK_IMPORTED_MODULE_7__["default"])();
                var arrowPaddingMin = arrowPaddingObject[mainSide];
                var arrowPaddingMax = arrowPaddingObject[altSide];
                var arrowLen = (0, _utils_within_js__WEBPACK_IMPORTED_MODULE_8__.within)(0, referenceRect[len], arrowRect[len]);
                var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
                var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
                var arrowOffsetParent = state.elements.arrow && (0, _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_9__["default"])(state.elements.arrow);
                var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
                var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
                var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;
                var tetherMax = offset + maxOffset - offsetModifierValue;
                var preventedOffset = (0, _utils_within_js__WEBPACK_IMPORTED_MODULE_8__.within)(tether ? (0, 
                _utils_math_js__WEBPACK_IMPORTED_MODULE_10__.min)(min, tetherMin) : min, offset, tether ? (0, 
                _utils_math_js__WEBPACK_IMPORTED_MODULE_10__.max)(max, tetherMax) : max);
                popperOffsets[mainAxis] = preventedOffset;
                data[mainAxis] = preventedOffset - offset;
            }
            if (checkAltAxis) {
                var _offsetModifierState$2;
                var _mainSide = mainAxis === "x" ? _enums_js__WEBPACK_IMPORTED_MODULE_5__.top : _enums_js__WEBPACK_IMPORTED_MODULE_5__.left;
                var _altSide = mainAxis === "x" ? _enums_js__WEBPACK_IMPORTED_MODULE_5__.bottom : _enums_js__WEBPACK_IMPORTED_MODULE_5__.right;
                var _offset = popperOffsets[altAxis];
                var _len = altAxis === "y" ? "height" : "width";
                var _min = _offset + overflow[_mainSide];
                var _max = _offset - overflow[_altSide];
                var isOriginSide = [ _enums_js__WEBPACK_IMPORTED_MODULE_5__.top, _enums_js__WEBPACK_IMPORTED_MODULE_5__.left ].indexOf(basePlacement) !== -1;
                var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
                var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
                var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
                var _preventedOffset = tether && isOriginSide ? (0, _utils_within_js__WEBPACK_IMPORTED_MODULE_8__.withinMaxClamp)(_tetherMin, _offset, _tetherMax) : (0, 
                _utils_within_js__WEBPACK_IMPORTED_MODULE_8__.within)(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
                popperOffsets[altAxis] = _preventedOffset;
                data[altAxis] = _preventedOffset - _offset;
            }
            state.modifiersData[name] = data;
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "preventOverflow",
            enabled: true,
            phase: "main",
            fn: preventOverflow,
            requiresIfExists: [ "offset" ]
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getAltAxis
        });
        function getAltAxis(axis) {
            return axis === "x" ? "y" : "x";
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getLayoutRect
        });
        var _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(223);
        function getLayoutRect(element) {
            var clientRect = (0, _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_0__["default"])(element);
            var width = element.offsetWidth;
            var height = element.offsetHeight;
            if (Math.abs(clientRect.width - width) <= 1) {
                width = clientRect.width;
            }
            if (Math.abs(clientRect.height - height) <= 1) {
                height = clientRect.height;
            }
            return {
                x: element.offsetLeft,
                y: element.offsetTop,
                width,
                height
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            within: () => within,
            withinMaxClamp: () => withinMaxClamp
        });
        var _math_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(204);
        function within(min, value, max) {
            return (0, _math_js__WEBPACK_IMPORTED_MODULE_0__.max)(min, (0, _math_js__WEBPACK_IMPORTED_MODULE_0__.min)(value, max));
        }
        function withinMaxClamp(min, value, max) {
            var v = within(min, value, max);
            return v > max ? max : v;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(199);
        var _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(235);
        var _dom_utils_contains_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(232);
        var _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(205);
        var _utils_getMainAxisFromPlacement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(202);
        var _utils_within_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(236);
        var _utils_mergePaddingObject_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(219);
        var _utils_expandToHashMap_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(221);
        var _enums_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(201);
        var _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(206);
        var toPaddingObject = function toPaddingObject(padding, state) {
            padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
                placement: state.placement
            })) : padding;
            return (0, _utils_mergePaddingObject_js__WEBPACK_IMPORTED_MODULE_0__["default"])(typeof padding !== "number" ? padding : (0, 
            _utils_expandToHashMap_js__WEBPACK_IMPORTED_MODULE_1__["default"])(padding, _enums_js__WEBPACK_IMPORTED_MODULE_2__.basePlacements));
        };
        function arrow(_ref) {
            var _state$modifiersData$;
            var state = _ref.state, name = _ref.name, options = _ref.options;
            var arrowElement = state.elements.arrow;
            var popperOffsets = state.modifiersData.popperOffsets;
            var basePlacement = (0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_3__["default"])(state.placement);
            var axis = (0, _utils_getMainAxisFromPlacement_js__WEBPACK_IMPORTED_MODULE_4__["default"])(basePlacement);
            var isVertical = [ _enums_js__WEBPACK_IMPORTED_MODULE_2__.left, _enums_js__WEBPACK_IMPORTED_MODULE_2__.right ].indexOf(basePlacement) >= 0;
            var len = isVertical ? "height" : "width";
            if (!arrowElement || !popperOffsets) {
                return;
            }
            var paddingObject = toPaddingObject(options.padding, state);
            var arrowRect = (0, _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_5__["default"])(arrowElement);
            var minProp = axis === "y" ? _enums_js__WEBPACK_IMPORTED_MODULE_2__.top : _enums_js__WEBPACK_IMPORTED_MODULE_2__.left;
            var maxProp = axis === "y" ? _enums_js__WEBPACK_IMPORTED_MODULE_2__.bottom : _enums_js__WEBPACK_IMPORTED_MODULE_2__.right;
            var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
            var startDiff = popperOffsets[axis] - state.rects.reference[axis];
            var arrowOffsetParent = (0, _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_6__["default"])(arrowElement);
            var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
            var centerToReference = endDiff / 2 - startDiff / 2;
            var min = paddingObject[minProp];
            var max = clientSize - arrowRect[len] - paddingObject[maxProp];
            var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
            var offset = (0, _utils_within_js__WEBPACK_IMPORTED_MODULE_7__.within)(min, center, max);
            var axisProp = axis;
            state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, 
            _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
        }
        function effect(_ref2) {
            var state = _ref2.state, options = _ref2.options;
            var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
            if (arrowElement == null) {
                return;
            }
            if (typeof arrowElement === "string") {
                arrowElement = state.elements.popper.querySelector(arrowElement);
                if (!arrowElement) {
                    return;
                }
            }
            if (true) {
                if (!(0, _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_8__.isHTMLElement)(arrowElement)) {
                    console.error([ 'Popper: "arrow" element must be an HTMLElement (not an SVGElement).', "To use an SVG arrow, wrap it in an HTMLElement that will be used as", "the arrow." ].join(" "));
                }
            }
            if (!(0, _dom_utils_contains_js__WEBPACK_IMPORTED_MODULE_9__["default"])(state.elements.popper, arrowElement)) {
                if (true) {
                    console.error([ 'Popper: "arrow" modifier\'s `element` must be a child of the popper', "element." ].join(" "));
                }
                return;
            }
            state.elements.arrow = arrowElement;
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "arrow",
            enabled: true,
            phase: "main",
            fn: arrow,
            effect,
            requires: [ "popperOffsets" ],
            requiresIfExists: [ "preventOverflow" ]
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _enums_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(201);
        var _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(218);
        function getSideOffsets(overflow, rect, preventedOffsets) {
            if (preventedOffsets === void 0) {
                preventedOffsets = {
                    x: 0,
                    y: 0
                };
            }
            return {
                top: overflow.top - rect.height - preventedOffsets.y,
                right: overflow.right - rect.width + preventedOffsets.x,
                bottom: overflow.bottom - rect.height + preventedOffsets.y,
                left: overflow.left - rect.width - preventedOffsets.x
            };
        }
        function isAnySideFullyClipped(overflow) {
            return [ _enums_js__WEBPACK_IMPORTED_MODULE_0__.top, _enums_js__WEBPACK_IMPORTED_MODULE_0__.right, _enums_js__WEBPACK_IMPORTED_MODULE_0__.bottom, _enums_js__WEBPACK_IMPORTED_MODULE_0__.left ].some((function(side) {
                return overflow[side] >= 0;
            }));
        }
        function hide(_ref) {
            var state = _ref.state, name = _ref.name;
            var referenceRect = state.rects.reference;
            var popperRect = state.rects.popper;
            var preventedOffsets = state.modifiersData.preventOverflow;
            var referenceOverflow = (0, _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_1__["default"])(state, {
                elementContext: "reference"
            });
            var popperAltOverflow = (0, _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_1__["default"])(state, {
                altBoundary: true
            });
            var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
            var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
            var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
            var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
            state.modifiersData[name] = {
                referenceClippingOffsets,
                popperEscapeOffsets,
                isReferenceHidden,
                hasPopperEscaped
            };
            state.attributes.popper = Object.assign({}, state.attributes.popper, {
                "data-popper-reference-hidden": isReferenceHidden,
                "data-popper-escaped": hasPopperEscaped
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = {
            name: "hide",
            enabled: true,
            phase: "main",
            requiresIfExists: [ "preventOverflow" ],
            fn: hide
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            createPopper: () => createPopper,
            detectOverflow: () => _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_13__["default"],
            popperGenerator: () => popperGenerator
        });
        var _dom_utils_getCompositeRect_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(245);
        var _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(235);
        var _dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(229);
        var _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(205);
        var _dom_utils_getComputedStyle_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(207);
        var _utils_orderModifiers_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(240);
        var _utils_debounce_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(248);
        var _utils_validateModifiers_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(243);
        var _utils_uniqueBy_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(242);
        var _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(199);
        var _utils_mergeByName_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(241);
        var _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(218);
        var _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
        var _enums_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(201);
        var INVALID_ELEMENT_ERROR = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
        var INFINITE_LOOP_ERROR = "Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.";
        var DEFAULT_OPTIONS = {
            placement: "bottom",
            modifiers: [],
            strategy: "absolute"
        };
        function areValidElements() {
            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }
            return !args.some((function(element) {
                return !(element && typeof element.getBoundingClientRect === "function");
            }));
        }
        function popperGenerator(generatorOptions) {
            if (generatorOptions === void 0) {
                generatorOptions = {};
            }
            var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
            return function createPopper(reference, popper, options) {
                if (options === void 0) {
                    options = defaultOptions;
                }
                var state = {
                    placement: "bottom",
                    orderedModifiers: [],
                    options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
                    modifiersData: {},
                    elements: {
                        reference,
                        popper
                    },
                    attributes: {},
                    styles: {}
                };
                var effectCleanupFns = [];
                var isDestroyed = false;
                var instance = {
                    state,
                    setOptions: function setOptions(setOptionsAction) {
                        var options = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
                        cleanupModifierEffects();
                        state.options = Object.assign({}, defaultOptions, state.options, options);
                        state.scrollParents = {
                            reference: (0, _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isElement)(reference) ? (0, 
                            _dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__["default"])(reference) : reference.contextElement ? (0, 
                            _dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__["default"])(reference.contextElement) : [],
                            popper: (0, _dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__["default"])(popper)
                        };
                        var orderedModifiers = (0, _utils_orderModifiers_js__WEBPACK_IMPORTED_MODULE_2__["default"])((0, 
                        _utils_mergeByName_js__WEBPACK_IMPORTED_MODULE_3__["default"])([].concat(defaultModifiers, state.options.modifiers)));
                        state.orderedModifiers = orderedModifiers.filter((function(m) {
                            return m.enabled;
                        }));
                        if (true) {
                            var modifiers = (0, _utils_uniqueBy_js__WEBPACK_IMPORTED_MODULE_4__["default"])([].concat(orderedModifiers, state.options.modifiers), (function(_ref) {
                                var name = _ref.name;
                                return name;
                            }));
                            (0, _utils_validateModifiers_js__WEBPACK_IMPORTED_MODULE_5__["default"])(modifiers);
                            if ((0, _utils_getBasePlacement_js__WEBPACK_IMPORTED_MODULE_6__["default"])(state.options.placement) === _enums_js__WEBPACK_IMPORTED_MODULE_7__.auto) {
                                var flipModifier = state.orderedModifiers.find((function(_ref2) {
                                    var name = _ref2.name;
                                    return name === "flip";
                                }));
                                if (!flipModifier) {
                                    console.error([ 'Popper: "auto" placements require the "flip" modifier be', "present and enabled to work." ].join(" "));
                                }
                            }
                            var _getComputedStyle = (0, _dom_utils_getComputedStyle_js__WEBPACK_IMPORTED_MODULE_8__["default"])(popper), marginTop = _getComputedStyle.marginTop, marginRight = _getComputedStyle.marginRight, marginBottom = _getComputedStyle.marginBottom, marginLeft = _getComputedStyle.marginLeft;
                            if ([ marginTop, marginRight, marginBottom, marginLeft ].some((function(margin) {
                                return parseFloat(margin);
                            }))) {
                                console.warn([ 'Popper: CSS "margin" styles cannot be used to apply padding', "between the popper and its reference element or boundary.", "To replicate margin, use the `offset` modifier, as well as", "the `padding` option in the `preventOverflow` and `flip`", "modifiers." ].join(" "));
                            }
                        }
                        runModifierEffects();
                        return instance.update();
                    },
                    forceUpdate: function forceUpdate() {
                        if (isDestroyed) {
                            return;
                        }
                        var _state$elements = state.elements, reference = _state$elements.reference, popper = _state$elements.popper;
                        if (!areValidElements(reference, popper)) {
                            if (true) {
                                console.error(INVALID_ELEMENT_ERROR);
                            }
                            return;
                        }
                        state.rects = {
                            reference: (0, _dom_utils_getCompositeRect_js__WEBPACK_IMPORTED_MODULE_9__["default"])(reference, (0, 
                            _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_10__["default"])(popper), state.options.strategy === "fixed"),
                            popper: (0, _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_11__["default"])(popper)
                        };
                        state.reset = false;
                        state.placement = state.options.placement;
                        state.orderedModifiers.forEach((function(modifier) {
                            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
                        }));
                        var __debug_loops__ = 0;
                        for (var index = 0; index < state.orderedModifiers.length; index++) {
                            if (true) {
                                __debug_loops__ += 1;
                                if (__debug_loops__ > 100) {
                                    console.error(INFINITE_LOOP_ERROR);
                                    break;
                                }
                            }
                            if (state.reset === true) {
                                state.reset = false;
                                index = -1;
                                continue;
                            }
                            var _state$orderedModifie = state.orderedModifiers[index], fn = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
                            if (typeof fn === "function") {
                                state = fn({
                                    state,
                                    options: _options,
                                    name,
                                    instance
                                }) || state;
                            }
                        }
                    },
                    update: (0, _utils_debounce_js__WEBPACK_IMPORTED_MODULE_12__["default"])((function() {
                        return new Promise((function(resolve) {
                            instance.forceUpdate();
                            resolve(state);
                        }));
                    })),
                    destroy: function destroy() {
                        cleanupModifierEffects();
                        isDestroyed = true;
                    }
                };
                if (!areValidElements(reference, popper)) {
                    if (true) {
                        console.error(INVALID_ELEMENT_ERROR);
                    }
                    return instance;
                }
                instance.setOptions(options).then((function(state) {
                    if (!isDestroyed && options.onFirstUpdate) {
                        options.onFirstUpdate(state);
                    }
                }));
                function runModifierEffects() {
                    state.orderedModifiers.forEach((function(_ref3) {
                        var name = _ref3.name, _ref3$options = _ref3.options, options = _ref3$options === void 0 ? {} : _ref3$options, effect = _ref3.effect;
                        if (typeof effect === "function") {
                            var cleanupFn = effect({
                                state,
                                name,
                                instance,
                                options
                            });
                            var noopFn = function noopFn() {};
                            effectCleanupFns.push(cleanupFn || noopFn);
                        }
                    }));
                }
                function cleanupModifierEffects() {
                    effectCleanupFns.forEach((function(fn) {
                        return fn();
                    }));
                    effectCleanupFns = [];
                }
                return instance;
            };
        }
        var createPopper = popperGenerator();
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => orderModifiers
        });
        var _enums_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(201);
        function order(modifiers) {
            var map = new Map;
            var visited = new Set;
            var result = [];
            modifiers.forEach((function(modifier) {
                map.set(modifier.name, modifier);
            }));
            function sort(modifier) {
                visited.add(modifier.name);
                var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
                requires.forEach((function(dep) {
                    if (!visited.has(dep)) {
                        var depModifier = map.get(dep);
                        if (depModifier) {
                            sort(depModifier);
                        }
                    }
                }));
                result.push(modifier);
            }
            modifiers.forEach((function(modifier) {
                if (!visited.has(modifier.name)) {
                    sort(modifier);
                }
            }));
            return result;
        }
        function orderModifiers(modifiers) {
            var orderedModifiers = order(modifiers);
            return _enums_js__WEBPACK_IMPORTED_MODULE_0__.modifierPhases.reduce((function(acc, phase) {
                return acc.concat(orderedModifiers.filter((function(modifier) {
                    return modifier.phase === phase;
                })));
            }), []);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => mergeByName
        });
        function mergeByName(modifiers) {
            var merged = modifiers.reduce((function(merged, current) {
                var existing = merged[current.name];
                merged[current.name] = existing ? Object.assign({}, existing, current, {
                    options: Object.assign({}, existing.options, current.options),
                    data: Object.assign({}, existing.data, current.data)
                }) : current;
                return merged;
            }), {});
            return Object.keys(merged).map((function(key) {
                return merged[key];
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => uniqueBy
        });
        function uniqueBy(arr, fn) {
            var identifiers = new Set;
            return arr.filter((function(item) {
                var identifier = fn(item);
                if (!identifiers.has(identifier)) {
                    identifiers.add(identifier);
                    return true;
                }
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => validateModifiers
        });
        var _format_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(244);
        var _enums_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(201);
        var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
        var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
        var VALID_PROPERTIES = [ "name", "enabled", "phase", "fn", "effect", "requires", "options" ];
        function validateModifiers(modifiers) {
            modifiers.forEach((function(modifier) {
                [].concat(Object.keys(modifier), VALID_PROPERTIES).filter((function(value, index, self) {
                    return self.indexOf(value) === index;
                })).forEach((function(key) {
                    switch (key) {
                      case "name":
                        if (typeof modifier.name !== "string") {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', '"' + String(modifier.name) + '"'));
                        }
                        break;

                      case "enabled":
                        if (typeof modifier.enabled !== "boolean") {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', '"' + String(modifier.enabled) + '"'));
                        }
                        break;

                      case "phase":
                        if (_enums_js__WEBPACK_IMPORTED_MODULE_1__.modifierPhases.indexOf(modifier.phase) < 0) {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + _enums_js__WEBPACK_IMPORTED_MODULE_1__.modifierPhases.join(", "), '"' + String(modifier.phase) + '"'));
                        }
                        break;

                      case "fn":
                        if (typeof modifier.fn !== "function") {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', '"' + String(modifier.fn) + '"'));
                        }
                        break;

                      case "effect":
                        if (modifier.effect != null && typeof modifier.effect !== "function") {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', '"' + String(modifier.fn) + '"'));
                        }
                        break;

                      case "requires":
                        if (modifier.requires != null && !Array.isArray(modifier.requires)) {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', '"' + String(modifier.requires) + '"'));
                        }
                        break;

                      case "requiresIfExists":
                        if (!Array.isArray(modifier.requiresIfExists)) {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', '"' + String(modifier.requiresIfExists) + '"'));
                        }
                        break;

                      case "options":
                      case "data":
                        break;

                      default:
                        console.error('PopperJS: an invalid property has been provided to the "' + modifier.name + '" modifier, valid properties are ' + VALID_PROPERTIES.map((function(s) {
                            return '"' + s + '"';
                        })).join(", ") + '; but "' + key + '" was provided.');
                    }
                    modifier.requires && modifier.requires.forEach((function(requirement) {
                        if (modifiers.find((function(mod) {
                            return mod.name === requirement;
                        })) == null) {
                            console.error((0, _format_js__WEBPACK_IMPORTED_MODULE_0__["default"])(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
                        }
                    }));
                }));
            }));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => format
        });
        function format(str) {
            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                args[_key - 1] = arguments[_key];
            }
            return [].concat(args).reduce((function(p, c) {
                return p.replace(/%s/, c);
            }), str);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getCompositeRect
        });
        var _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(223);
        var _getNodeScroll_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(246);
        var _getNodeName_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(209);
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(206);
        var _getWindowScrollBarX_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(226);
        var _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(210);
        var _isScrollParent_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(231);
        var _utils_math_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(204);
        function isElementScaled(element) {
            var rect = element.getBoundingClientRect();
            var scaleX = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_0__.round)(rect.width) / element.offsetWidth || 1;
            var scaleY = (0, _utils_math_js__WEBPACK_IMPORTED_MODULE_0__.round)(rect.height) / element.offsetHeight || 1;
            return scaleX !== 1 || scaleY !== 1;
        }
        function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
            if (isFixed === void 0) {
                isFixed = false;
            }
            var isOffsetParentAnElement = (0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(offsetParent);
            var offsetParentIsScaled = (0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(offsetParent) && isElementScaled(offsetParent);
            var documentElement = (0, _getDocumentElement_js__WEBPACK_IMPORTED_MODULE_2__["default"])(offsetParent);
            var rect = (0, _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_3__["default"])(elementOrVirtualElement, offsetParentIsScaled);
            var scroll = {
                scrollLeft: 0,
                scrollTop: 0
            };
            var offsets = {
                x: 0,
                y: 0
            };
            if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
                if ((0, _getNodeName_js__WEBPACK_IMPORTED_MODULE_4__["default"])(offsetParent) !== "body" || (0, 
                _isScrollParent_js__WEBPACK_IMPORTED_MODULE_5__["default"])(documentElement)) {
                    scroll = (0, _getNodeScroll_js__WEBPACK_IMPORTED_MODULE_6__["default"])(offsetParent);
                }
                if ((0, _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(offsetParent)) {
                    offsets = (0, _getBoundingClientRect_js__WEBPACK_IMPORTED_MODULE_3__["default"])(offsetParent, true);
                    offsets.x += offsetParent.clientLeft;
                    offsets.y += offsetParent.clientTop;
                } else if (documentElement) {
                    offsets.x = (0, _getWindowScrollBarX_js__WEBPACK_IMPORTED_MODULE_7__["default"])(documentElement);
                }
            }
            return {
                x: rect.left + scroll.scrollLeft - offsets.x,
                y: rect.top + scroll.scrollTop - offsets.y,
                width: rect.width,
                height: rect.height
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getNodeScroll
        });
        var _getWindowScroll_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(227);
        var _getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(196);
        var _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(206);
        var _getHTMLElementScroll_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(247);
        function getNodeScroll(node) {
            if (node === (0, _getWindow_js__WEBPACK_IMPORTED_MODULE_0__["default"])(node) || !(0, 
            _instanceOf_js__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(node)) {
                return (0, _getWindowScroll_js__WEBPACK_IMPORTED_MODULE_2__["default"])(node);
            } else {
                return (0, _getHTMLElementScroll_js__WEBPACK_IMPORTED_MODULE_3__["default"])(node);
            }
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => getHTMLElementScroll
        });
        function getHTMLElementScroll(element) {
            return {
                scrollLeft: element.scrollLeft,
                scrollTop: element.scrollTop
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => debounce
        });
        function debounce(fn) {
            var pending;
            return function() {
                if (!pending) {
                    pending = new Promise((function(resolve) {
                        Promise.resolve().then((function() {
                            pending = undefined;
                            resolve(fn());
                        }));
                    }));
                }
                return pending;
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            createPopper: () => createPopper,
            defaultModifiers: () => defaultModifiers,
            detectOverflow: () => _createPopper_js__WEBPACK_IMPORTED_MODULE_5__["default"],
            popperGenerator: () => _createPopper_js__WEBPACK_IMPORTED_MODULE_4__.popperGenerator
        });
        var _createPopper_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(239);
        var _createPopper_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(218);
        var _modifiers_eventListeners_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(195);
        var _modifiers_popperOffsets_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(197);
        var _modifiers_computeStyles_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(203);
        var _modifiers_applyStyles_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(212);
        var defaultModifiers = [ _modifiers_eventListeners_js__WEBPACK_IMPORTED_MODULE_0__["default"], _modifiers_popperOffsets_js__WEBPACK_IMPORTED_MODULE_1__["default"], _modifiers_computeStyles_js__WEBPACK_IMPORTED_MODULE_2__["default"], _modifiers_applyStyles_js__WEBPACK_IMPORTED_MODULE_3__["default"] ];
        var createPopper = (0, _createPopper_js__WEBPACK_IMPORTED_MODULE_4__.popperGenerator)({
            defaultModifiers
        });
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            applyStyles: () => _applyStyles_js__WEBPACK_IMPORTED_MODULE_0__["default"],
            arrow: () => _arrow_js__WEBPACK_IMPORTED_MODULE_1__["default"],
            computeStyles: () => _computeStyles_js__WEBPACK_IMPORTED_MODULE_2__["default"],
            eventListeners: () => _eventListeners_js__WEBPACK_IMPORTED_MODULE_3__["default"],
            flip: () => _flip_js__WEBPACK_IMPORTED_MODULE_4__["default"],
            hide: () => _hide_js__WEBPACK_IMPORTED_MODULE_5__["default"],
            offset: () => _offset_js__WEBPACK_IMPORTED_MODULE_6__["default"],
            popperOffsets: () => _popperOffsets_js__WEBPACK_IMPORTED_MODULE_7__["default"],
            preventOverflow: () => _preventOverflow_js__WEBPACK_IMPORTED_MODULE_8__["default"]
        });
        var _applyStyles_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(212);
        var _arrow_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(237);
        var _computeStyles_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(203);
        var _eventListeners_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(195);
        var _flip_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(214);
        var _hide_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(238);
        var _offset_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(213);
        var _popperOffsets_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(197);
        var _preventOverflow_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(233);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var react_popper__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(191);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function Tooltip() {
            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
                placement: "top"
            }, children = _ref.children, content = _ref.content, placement = _ref.placement;
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(false), _useState2 = _slicedToArray(_useState, 2), isOpen = _useState2[0], setIsOpen = _useState2[1];
            var _useState3 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState4 = _slicedToArray(_useState3, 2), referenceElement = _useState4[0], setReferenceElement = _useState4[1];
            var _useState5 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState6 = _slicedToArray(_useState5, 2), popperElement = _useState6[0], setPopperElement = _useState6[1];
            var _useState7 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState8 = _slicedToArray(_useState7, 2), arrowElement = _useState8[0], setArrowElement = _useState8[1];
            var _usePopper = (0, react_popper__WEBPACK_IMPORTED_MODULE_2__.usePopper)(referenceElement, popperElement, {
                placement,
                modifiers: [ {
                    name: "offset",
                    options: {
                        offset: [ 0, 8 ]
                    }
                }, {
                    name: "arrow",
                    options: {
                        element: arrowElement
                    }
                } ]
            }), styles = _usePopper.styles, attributes = _usePopper.attributes;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsxs)(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.Fragment, {
                children: [ children({
                    props: {
                        ref: setReferenceElement,
                        onMouseEnter: function onMouseEnter() {
                            setIsOpen(true);
                        },
                        onMouseLeave: function onMouseLeave() {
                            setIsOpen(false);
                        }
                    }
                }), isOpen && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsxs)("div", _objectSpread(_objectSpread({
                    className: "lotta-tooltip",
                    ref: setPopperElement,
                    style: styles.popper
                }, attributes.popper), {}, {
                    children: [ content, (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("div", {
                        ref: setArrowElement,
                        style: styles.arrow,
                        className: "lotta-popup-arrow"
                    }) ]
                })) ]
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = Tooltip;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => ReactColorPicker
        });
        var _wordpress_components__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(253);
        var _wordpress_components__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_components__WEBPACK_IMPORTED_MODULE_0__);
        var _tooltip__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(251);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
        var _index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(254);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        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);
        }
        function hex2rgba(hex) {
            if (hex.length < 9 || hex[0] != "#") return hex;
            var r = parseInt(hex.slice(1, 3), 16);
            var g = parseInt(hex.slice(3, 5), 16);
            var b = parseInt(hex.slice(5, 7), 16);
            var a = (parseInt(hex.slice(7, 9), 16) / 255).toFixed(2);
            return "rgba(" + r + "," + g + "," + b + "," + a + ")";
        }
        function ReactColorPicker(props) {
            var swatches = props.swatches;
            var hasMeta = !Array.isArray(swatches) && _typeof(swatches) === "object";
            if (hasMeta) {
                swatches = Object.keys(swatches);
            }
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                className: "lotta-react-color-picker",
                children: [ swatches && swatches.length > 0 && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.Fragment, {
                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("h4", {
                        className: "category-title",
                        children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)("Theme")
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                        className: "swatches",
                        children: swatches.map((function(color, i) {
                            var label = hasMeta && props.swatches[color] ? props.swatches[color] : "";
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                className: "swatch-wrap",
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                                        swatch: true,
                                        "initial-swatch": color === _index__WEBPACK_IMPORTED_MODULE_4__.CSS_INITIAL_VALUE,
                                        active: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.getColorValue)(color) === (0, _utils__WEBPACK_IMPORTED_MODULE_3__.getColorValue)(props.color)
                                    }),
                                    style: {
                                        color
                                    },
                                    onClick: function onClick() {
                                        return props.onChange(color);
                                    },
                                    children: label ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_tooltip__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                        content: label,
                                        placement: "top",
                                        children: function children(_ref) {
                                            var props = _ref.props;
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", _objectSpread({
                                                className: "swatch-inner"
                                            }, props));
                                        }
                                    }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                        className: "swatch-inner"
                                    })
                                })
                            }, i);
                        }))
                    }) ]
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("h4", {
                    className: "category-title",
                    children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)("Custom")
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_wordpress_components__WEBPACK_IMPORTED_MODULE_0__.ColorPicker, {
                    className: "color-picker",
                    color: props.color,
                    enableAlpha: props.enableAlpha,
                    defaultValue: props.defaultValue || props.color,
                    onChange: function onChange(value) {
                        return props.onChange(hex2rgba(value));
                    }
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                    className: "color-picker-value",
                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("input", {
                        type: "text",
                        value: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.getColorValue)(props.color),
                        onChange: function onChange(e) {
                            props.onChange(hex2rgba(e.target.value));
                        }
                    })
                }) ]
            });
        }
    }, module => {
        "use strict";
        module.exports = window.wp.components;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            __: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.__,
            _n: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__._n,
            _nx: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__._nx,
            _x: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__._x,
            createI18n: () => _create_i18n__WEBPACK_IMPORTED_MODULE_1__.createI18n,
            defaultI18n: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__["default"],
            getLocaleData: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.getLocaleData,
            hasTranslation: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.hasTranslation,
            isRTL: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.isRTL,
            resetLocaleData: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.resetLocaleData,
            setLocaleData: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.setLocaleData,
            sprintf: () => _sprintf__WEBPACK_IMPORTED_MODULE_0__.sprintf,
            subscribe: () => _default_i18n__WEBPACK_IMPORTED_MODULE_2__.subscribe
        });
        var _sprintf__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(255);
        var _create_i18n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(258);
        var _default_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(264);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            sprintf: () => sprintf
        });
        var memize__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(256);
        var memize__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(memize__WEBPACK_IMPORTED_MODULE_0__);
        var sprintf_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(257);
        var sprintf_js__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(sprintf_js__WEBPACK_IMPORTED_MODULE_1__);
        const logErrorOnce = memize__WEBPACK_IMPORTED_MODULE_0___default()(console.error);
        function sprintf(format) {
            try {
                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                    args[_key - 1] = arguments[_key];
                }
                return sprintf_js__WEBPACK_IMPORTED_MODULE_1___default().sprintf(format, ...args);
            } catch (error) {
                if (error instanceof Error) {
                    logErrorOnce("sprintf error: \n\n" + error.toString());
                }
                return format;
            }
        }
    }, module => {
        function memize(fn, options) {
            var size = 0;
            var head;
            var tail;
            options = options || {};
            function memoized() {
                var node = head, len = arguments.length, args, i;
                searchCache: while (node) {
                    if (node.args.length !== arguments.length) {
                        node = node.next;
                        continue;
                    }
                    for (i = 0; i < len; i++) {
                        if (node.args[i] !== arguments[i]) {
                            node = node.next;
                            continue searchCache;
                        }
                    }
                    if (node !== head) {
                        if (node === tail) {
                            tail = node.prev;
                        }
                        node.prev.next = node.next;
                        if (node.next) {
                            node.next.prev = node.prev;
                        }
                        node.next = head;
                        node.prev = null;
                        head.prev = node;
                        head = node;
                    }
                    return node.val;
                }
                args = new Array(len);
                for (i = 0; i < len; i++) {
                    args[i] = arguments[i];
                }
                node = {
                    args,
                    val: fn.apply(null, args)
                };
                if (head) {
                    head.prev = node;
                    node.next = head;
                } else {
                    tail = node;
                }
                if (size === options.maxSize) {
                    tail = tail.prev;
                    tail.next = null;
                } else {
                    size++;
                }
                head = node;
                return node.val;
            }
            memoized.clear = function() {
                head = null;
                tail = null;
                size = 0;
            };
            if (false) {}
            return memoized;
        }
        module.exports = memize;
    }, (module, exports, __webpack_require__) => {
        var __WEBPACK_AMD_DEFINE_RESULT__;
        !function() {
            "use strict";
            var re = {
                not_string: /[^s]/,
                not_bool: /[^t]/,
                not_type: /[^T]/,
                not_primitive: /[^v]/,
                number: /[diefg]/,
                numeric_arg: /[bcdiefguxX]/,
                json: /[j]/,
                not_json: /[^j]/,
                text: /^[^\x25]+/,
                modulo: /^\x25{2}/,
                placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
                key: /^([a-z_][a-z_\d]*)/i,
                key_access: /^\.([a-z_][a-z_\d]*)/i,
                index_access: /^\[(\d+)\]/,
                sign: /^[+-]/
            };
            function sprintf(key) {
                return sprintf_format(sprintf_parse(key), arguments);
            }
            function vsprintf(fmt, argv) {
                return sprintf.apply(null, [ fmt ].concat(argv || []));
            }
            function sprintf_format(parse_tree, argv) {
                var cursor = 1, tree_length = parse_tree.length, arg, output = "", i, k, ph, pad, pad_character, pad_length, is_positive, sign;
                for (i = 0; i < tree_length; i++) {
                    if (typeof parse_tree[i] === "string") {
                        output += parse_tree[i];
                    } else if (typeof parse_tree[i] === "object") {
                        ph = parse_tree[i];
                        if (ph.keys) {
                            arg = argv[cursor];
                            for (k = 0; k < ph.keys.length; k++) {
                                if (arg == undefined) {
                                    throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k - 1]));
                                }
                                arg = arg[ph.keys[k]];
                            }
                        } else if (ph.param_no) {
                            arg = argv[ph.param_no];
                        } else {
                            arg = argv[cursor++];
                        }
                        if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {
                            arg = arg();
                        }
                        if (re.numeric_arg.test(ph.type) && (typeof arg !== "number" && isNaN(arg))) {
                            throw new TypeError(sprintf("[sprintf] expecting number but found %T", arg));
                        }
                        if (re.number.test(ph.type)) {
                            is_positive = arg >= 0;
                        }
                        switch (ph.type) {
                          case "b":
                            arg = parseInt(arg, 10).toString(2);
                            break;

                          case "c":
                            arg = String.fromCharCode(parseInt(arg, 10));
                            break;

                          case "d":
                          case "i":
                            arg = parseInt(arg, 10);
                            break;

                          case "j":
                            arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0);
                            break;

                          case "e":
                            arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential();
                            break;

                          case "f":
                            arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg);
                            break;

                          case "g":
                            arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg);
                            break;

                          case "o":
                            arg = (parseInt(arg, 10) >>> 0).toString(8);
                            break;

                          case "s":
                            arg = String(arg);
                            arg = ph.precision ? arg.substring(0, ph.precision) : arg;
                            break;

                          case "t":
                            arg = String(!!arg);
                            arg = ph.precision ? arg.substring(0, ph.precision) : arg;
                            break;

                          case "T":
                            arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase();
                            arg = ph.precision ? arg.substring(0, ph.precision) : arg;
                            break;

                          case "u":
                            arg = parseInt(arg, 10) >>> 0;
                            break;

                          case "v":
                            arg = arg.valueOf();
                            arg = ph.precision ? arg.substring(0, ph.precision) : arg;
                            break;

                          case "x":
                            arg = (parseInt(arg, 10) >>> 0).toString(16);
                            break;

                          case "X":
                            arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase();
                            break;
                        }
                        if (re.json.test(ph.type)) {
                            output += arg;
                        } else {
                            if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
                                sign = is_positive ? "+" : "-";
                                arg = arg.toString().replace(re.sign, "");
                            } else {
                                sign = "";
                            }
                            pad_character = ph.pad_char ? ph.pad_char === "0" ? "0" : ph.pad_char.charAt(1) : " ";
                            pad_length = ph.width - (sign + arg).length;
                            pad = ph.width ? pad_length > 0 ? pad_character.repeat(pad_length) : "" : "";
                            output += ph.align ? sign + arg + pad : pad_character === "0" ? sign + pad + arg : pad + sign + arg;
                        }
                    }
                }
                return output;
            }
            var sprintf_cache = Object.create(null);
            function sprintf_parse(fmt) {
                if (sprintf_cache[fmt]) {
                    return sprintf_cache[fmt];
                }
                var _fmt = fmt, match, parse_tree = [], arg_names = 0;
                while (_fmt) {
                    if ((match = re.text.exec(_fmt)) !== null) {
                        parse_tree.push(match[0]);
                    } else if ((match = re.modulo.exec(_fmt)) !== null) {
                        parse_tree.push("%");
                    } else if ((match = re.placeholder.exec(_fmt)) !== null) {
                        if (match[2]) {
                            arg_names |= 1;
                            var field_list = [], replacement_field = match[2], field_match = [];
                            if ((field_match = re.key.exec(replacement_field)) !== null) {
                                field_list.push(field_match[1]);
                                while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") {
                                    if ((field_match = re.key_access.exec(replacement_field)) !== null) {
                                        field_list.push(field_match[1]);
                                    } else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
                                        field_list.push(field_match[1]);
                                    } else {
                                        throw new SyntaxError("[sprintf] failed to parse named argument key");
                                    }
                                }
                            } else {
                                throw new SyntaxError("[sprintf] failed to parse named argument key");
                            }
                            match[2] = field_list;
                        } else {
                            arg_names |= 2;
                        }
                        if (arg_names === 3) {
                            throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");
                        }
                        parse_tree.push({
                            placeholder: match[0],
                            param_no: match[1],
                            keys: match[2],
                            sign: match[3],
                            pad_char: match[4],
                            align: match[5],
                            width: match[6],
                            precision: match[7],
                            type: match[8]
                        });
                    } else {
                        throw new SyntaxError("[sprintf] unexpected placeholder");
                    }
                    _fmt = _fmt.substring(match[0].length);
                }
                return sprintf_cache[fmt] = parse_tree;
            }
            if (true) {
                exports.sprintf = sprintf;
                exports.vsprintf = vsprintf;
            }
            if (typeof window !== "undefined") {
                window["sprintf"] = sprintf;
                window["vsprintf"] = vsprintf;
                if (true) {
                    !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
                        return {
                            sprintf,
                            vsprintf
                        };
                    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
                }
            }
        }();
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            createI18n: () => createI18n
        });
        var tannin__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(259);
        const DEFAULT_LOCALE_DATA = {
            "": {
                plural_forms(n) {
                    return n === 1 ? 0 : 1;
                }
            }
        };
        const I18N_HOOK_REGEXP = /^i18n\.(n?gettext|has_translation)(_|$)/;
        const createI18n = (initialData, initialDomain, hooks) => {
            const tannin = new tannin__WEBPACK_IMPORTED_MODULE_0__["default"]({});
            const listeners = new Set;
            const notifyListeners = () => {
                listeners.forEach((listener => listener()));
            };
            const subscribe = callback => {
                listeners.add(callback);
                return () => listeners.delete(callback);
            };
            const getLocaleData = function() {
                let domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
                return tannin.data[domain];
            };
            const doSetLocaleData = function(data) {
                var _tannin$data$domain;
                let domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "default";
                tannin.data[domain] = {
                    ...tannin.data[domain],
                    ...data
                };
                tannin.data[domain][""] = {
                    ...DEFAULT_LOCALE_DATA[""],
                    ...(_tannin$data$domain = tannin.data[domain]) === null || _tannin$data$domain === void 0 ? void 0 : _tannin$data$domain[""]
                };
                delete tannin.pluralForms[domain];
            };
            const setLocaleData = (data, domain) => {
                doSetLocaleData(data, domain);
                notifyListeners();
            };
            const addLocaleData = function(data) {
                var _tannin$data$domain2;
                let domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "default";
                tannin.data[domain] = {
                    ...tannin.data[domain],
                    ...data,
                    "": {
                        ...DEFAULT_LOCALE_DATA[""],
                        ...(_tannin$data$domain2 = tannin.data[domain]) === null || _tannin$data$domain2 === void 0 ? void 0 : _tannin$data$domain2[""],
                        ...data === null || data === void 0 ? void 0 : data[""]
                    }
                };
                delete tannin.pluralForms[domain];
                notifyListeners();
            };
            const resetLocaleData = (data, domain) => {
                tannin.data = {};
                tannin.pluralForms = {};
                setLocaleData(data, domain);
            };
            const dcnpgettext = function() {
                let domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
                let context = arguments.length > 1 ? arguments[1] : undefined;
                let single = arguments.length > 2 ? arguments[2] : undefined;
                let plural = arguments.length > 3 ? arguments[3] : undefined;
                let number = arguments.length > 4 ? arguments[4] : undefined;
                if (!tannin.data[domain]) {
                    doSetLocaleData(undefined, domain);
                }
                return tannin.dcnpgettext(domain, context, single, plural, number);
            };
            const getFilterDomain = function() {
                let domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
                return domain;
            };
            const __ = (text, domain) => {
                let translation = dcnpgettext(domain, undefined, text);
                if (!hooks) {
                    return translation;
                }
                translation = hooks.applyFilters("i18n.gettext", translation, text, domain);
                return hooks.applyFilters("i18n.gettext_" + getFilterDomain(domain), translation, text, domain);
            };
            const _x = (text, context, domain) => {
                let translation = dcnpgettext(domain, context, text);
                if (!hooks) {
                    return translation;
                }
                translation = hooks.applyFilters("i18n.gettext_with_context", translation, text, context, domain);
                return hooks.applyFilters("i18n.gettext_with_context_" + getFilterDomain(domain), translation, text, context, domain);
            };
            const _n = (single, plural, number, domain) => {
                let translation = dcnpgettext(domain, undefined, single, plural, number);
                if (!hooks) {
                    return translation;
                }
                translation = hooks.applyFilters("i18n.ngettext", translation, single, plural, number, domain);
                return hooks.applyFilters("i18n.ngettext_" + getFilterDomain(domain), translation, single, plural, number, domain);
            };
            const _nx = (single, plural, number, context, domain) => {
                let translation = dcnpgettext(domain, context, single, plural, number);
                if (!hooks) {
                    return translation;
                }
                translation = hooks.applyFilters("i18n.ngettext_with_context", translation, single, plural, number, context, domain);
                return hooks.applyFilters("i18n.ngettext_with_context_" + getFilterDomain(domain), translation, single, plural, number, context, domain);
            };
            const isRTL = () => "rtl" === _x("ltr", "text direction");
            const hasTranslation = (single, context, domain) => {
                var _tannin$data, _tannin$data2;
                const key = context ? context + "" + single : single;
                let result = !!((_tannin$data = tannin.data) !== null && _tannin$data !== void 0 && (_tannin$data2 = _tannin$data[domain !== null && domain !== void 0 ? domain : "default"]) !== null && _tannin$data2 !== void 0 && _tannin$data2[key]);
                if (hooks) {
                    result = hooks.applyFilters("i18n.has_translation", result, single, context, domain);
                    result = hooks.applyFilters("i18n.has_translation_" + getFilterDomain(domain), result, single, context, domain);
                }
                return result;
            };
            if (initialData) {
                setLocaleData(initialData, initialDomain);
            }
            if (hooks) {
                const onHookAddedOrRemoved = hookName => {
                    if (I18N_HOOK_REGEXP.test(hookName)) {
                        notifyListeners();
                    }
                };
                hooks.addAction("hookAdded", "core/i18n", onHookAddedOrRemoved);
                hooks.addAction("hookRemoved", "core/i18n", onHookAddedOrRemoved);
            }
            return {
                getLocaleData,
                setLocaleData,
                addLocaleData,
                resetLocaleData,
                subscribe,
                __,
                _x,
                _n,
                _nx,
                isRTL,
                hasTranslation
            };
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Tannin
        });
        var _tannin_plural_forms__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(260);
        var DEFAULT_OPTIONS = {
            contextDelimiter: "",
            onMissingKey: null
        };
        function getPluralExpression(pf) {
            var parts, i, part;
            parts = pf.split(";");
            for (i = 0; i < parts.length; i++) {
                part = parts[i].trim();
                if (part.indexOf("plural=") === 0) {
                    return part.substr(7);
                }
            }
        }
        function Tannin(data, options) {
            var key;
            this.data = data;
            this.pluralForms = {};
            this.options = {};
            for (key in DEFAULT_OPTIONS) {
                this.options[key] = options !== undefined && key in options ? options[key] : DEFAULT_OPTIONS[key];
            }
        }
        Tannin.prototype.getPluralForm = function(domain, n) {
            var getPluralForm = this.pluralForms[domain], config, plural, pf;
            if (!getPluralForm) {
                config = this.data[domain][""];
                pf = config["Plural-Forms"] || config["plural-forms"] || config.plural_forms;
                if (typeof pf !== "function") {
                    plural = getPluralExpression(config["Plural-Forms"] || config["plural-forms"] || config.plural_forms);
                    pf = (0, _tannin_plural_forms__WEBPACK_IMPORTED_MODULE_0__["default"])(plural);
                }
                getPluralForm = this.pluralForms[domain] = pf;
            }
            return getPluralForm(n);
        };
        Tannin.prototype.dcnpgettext = function(domain, context, singular, plural, n) {
            var index, key, entry;
            if (n === undefined) {
                index = 0;
            } else {
                index = this.getPluralForm(domain, n);
            }
            key = singular;
            if (context) {
                key = context + this.options.contextDelimiter + singular;
            }
            entry = this.data[domain][key];
            if (entry && entry[index]) {
                return entry[index];
            }
            if (this.options.onMissingKey) {
                this.options.onMissingKey(singular, domain);
            }
            return index === 0 ? singular : plural;
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => pluralForms
        });
        var _tannin_compile__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(261);
        function pluralForms(expression) {
            var evaluate = (0, _tannin_compile__WEBPACK_IMPORTED_MODULE_0__["default"])(expression);
            return function(n) {
                return +evaluate({
                    n
                });
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => compile
        });
        var _tannin_postfix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(262);
        var _tannin_evaluate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(263);
        function compile(expression) {
            var terms = (0, _tannin_postfix__WEBPACK_IMPORTED_MODULE_0__["default"])(expression);
            return function(variables) {
                return (0, _tannin_evaluate__WEBPACK_IMPORTED_MODULE_1__["default"])(terms, variables);
            };
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => postfix
        });
        var PRECEDENCE, OPENERS, TERMINATORS, PATTERN;
        PRECEDENCE = {
            "(": 9,
            "!": 8,
            "*": 7,
            "/": 7,
            "%": 7,
            "+": 6,
            "-": 6,
            "<": 5,
            "<=": 5,
            ">": 5,
            ">=": 5,
            "==": 4,
            "!=": 4,
            "&&": 3,
            "||": 2,
            "?": 1,
            "?:": 1
        };
        OPENERS = [ "(", "?" ];
        TERMINATORS = {
            ")": [ "(" ],
            ":": [ "?", "?:" ]
        };
        PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/;
        function postfix(expression) {
            var terms = [], stack = [], match, operator, term, element;
            while (match = expression.match(PATTERN)) {
                operator = match[0];
                term = expression.substr(0, match.index).trim();
                if (term) {
                    terms.push(term);
                }
                while (element = stack.pop()) {
                    if (TERMINATORS[operator]) {
                        if (TERMINATORS[operator][0] === element) {
                            operator = TERMINATORS[operator][1] || operator;
                            break;
                        }
                    } else if (OPENERS.indexOf(element) >= 0 || PRECEDENCE[element] < PRECEDENCE[operator]) {
                        stack.push(element);
                        break;
                    }
                    terms.push(element);
                }
                if (!TERMINATORS[operator]) {
                    stack.push(operator);
                }
                expression = expression.substr(match.index + operator.length);
            }
            expression = expression.trim();
            if (expression) {
                terms.push(expression);
            }
            return terms.concat(stack.reverse());
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => evaluate
        });
        var OPERATORS = {
            "!": function(a) {
                return !a;
            },
            "*": function(a, b) {
                return a * b;
            },
            "/": function(a, b) {
                return a / b;
            },
            "%": function(a, b) {
                return a % b;
            },
            "+": function(a, b) {
                return a + b;
            },
            "-": function(a, b) {
                return a - b;
            },
            "<": function(a, b) {
                return a < b;
            },
            "<=": function(a, b) {
                return a <= b;
            },
            ">": function(a, b) {
                return a > b;
            },
            ">=": function(a, b) {
                return a >= b;
            },
            "==": function(a, b) {
                return a === b;
            },
            "!=": function(a, b) {
                return a !== b;
            },
            "&&": function(a, b) {
                return a && b;
            },
            "||": function(a, b) {
                return a || b;
            },
            "?:": function(a, b, c) {
                if (a) {
                    throw b;
                }
                return c;
            }
        };
        function evaluate(postfix, variables) {
            var stack = [], i, j, args, getOperatorResult, term, value;
            for (i = 0; i < postfix.length; i++) {
                term = postfix[i];
                getOperatorResult = OPERATORS[term];
                if (getOperatorResult) {
                    j = getOperatorResult.length;
                    args = Array(j);
                    while (j--) {
                        args[j] = stack.pop();
                    }
                    try {
                        value = getOperatorResult.apply(null, args);
                    } catch (earlyReturn) {
                        return earlyReturn;
                    }
                } else if (variables.hasOwnProperty(term)) {
                    value = variables[term];
                } else {
                    value = +term;
                }
                stack.push(value);
            }
            return stack[0];
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            __: () => __,
            _n: () => _n,
            _nx: () => _nx,
            _x: () => _x,
            default: () => __WEBPACK_DEFAULT_EXPORT__,
            getLocaleData: () => getLocaleData,
            hasTranslation: () => hasTranslation,
            isRTL: () => isRTL,
            resetLocaleData: () => resetLocaleData,
            setLocaleData: () => setLocaleData,
            subscribe: () => subscribe
        });
        var _create_i18n__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(258);
        var _wordpress_hooks__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(265);
        var _wordpress_hooks__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(_wordpress_hooks__WEBPACK_IMPORTED_MODULE_1__);
        const i18n = (0, _create_i18n__WEBPACK_IMPORTED_MODULE_0__.createI18n)(undefined, undefined, _wordpress_hooks__WEBPACK_IMPORTED_MODULE_1__.defaultHooks);
        const __WEBPACK_DEFAULT_EXPORT__ = i18n;
        const getLocaleData = i18n.getLocaleData.bind(i18n);
        const setLocaleData = i18n.setLocaleData.bind(i18n);
        const resetLocaleData = i18n.resetLocaleData.bind(i18n);
        const subscribe = i18n.subscribe.bind(i18n);
        const __ = i18n.__.bind(i18n);
        const _x = i18n._x.bind(i18n);
        const _n = i18n._n.bind(i18n);
        const _nx = i18n._nx.bind(i18n);
        const isRTL = i18n.isRTL.bind(i18n);
        const hasTranslation = i18n.hasTranslation.bind(i18n);
    }, module => {
        "use strict";
        module.exports = window.wp.hooks;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(254);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var react_outside_click_handler__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(79);
        var _color_picker__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(189);
        var _utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4);
        var _index__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(5);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(10);
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        var Border = function Border(_ref) {
            var _clsx;
            var value = _ref.value, options = _ref.options, _onChange = _ref.onChange;
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(false), _useState2 = _slicedToArray(_useState, 2), isOpen = _useState2[0], setIsOpen = _useState2[1];
            value = Object.assign({
                width: 1,
                color: _index__WEBPACK_IMPORTED_MODULE_6__.CSS_INITIAL_VALUE
            }, value);
            var colors = [ {
                id: "color",
                title: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("Initial")
            } ];
            var colorValues = {
                color: value.color || ""
            };
            if (options.enableHover) {
                colors.push({
                    id: "hover",
                    title: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("Hover")
                });
                colorValues["hover"] = value.hover || "";
            }
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsxs)("div", {
                className: "lotta-border",
                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsxs)("div", {
                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])("lotta-value-changer", (_clsx = {}, 
                    _defineProperty(_clsx, "active", isOpen), _defineProperty(_clsx, "lotta-disabled", value.style === "none" || value.inherit), 
                    _clsx)),
                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("input", {
                        type: "number",
                        value: value.width,
                        disabled: value.style === "none",
                        onChange: function onChange(_ref2) {
                            var width = _ref2.target.value;
                            return _onChange(_objectSpread(_objectSpread({}, value), {}, {
                                width: (0, _utils__WEBPACK_IMPORTED_MODULE_5__.clamp)(1, 100, parseInt(width, 10) || 1)
                            }));
                        }
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("span", {
                        className: "lotta-value-divider"
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("span", {
                        className: "lotta-current-value",
                        "data-style": value.inherit ? "none" : value.style,
                        onClick: function onClick() {
                            return setIsOpen(!isOpen);
                        },
                        children: value.inherit ? (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("Inherit") : value.style === "none" ? (0, 
                        _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("none") : null
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(react_outside_click_handler__WEBPACK_IMPORTED_MODULE_3__["default"], {
                        disabled: !isOpen,
                        onOutsideClick: function onOutsideClick() {
                            if (!isOpen) return;
                            setIsOpen(false);
                        },
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("ul", {
                            className: "lotta-styles-list",
                            children: [ "solid", "dashed", "dotted", "none" ].reduce((function(current, el, index) {
                                return [].concat(_toConsumableArray(current.slice(0, index % 2 === 0 ? undefined : -1)), _toConsumableArray(index % 2 === 0 ? [ [ el ] ] : [ [ current[current.length - 1][0], el ] ]));
                            }), []).map((function(group) {
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("li", {
                                    children: group.map((function(style) {
                                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("span", {
                                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                                                active: style === value.style
                                            }),
                                            "data-style": style,
                                            onClick: function onClick() {
                                                _onChange(_objectSpread(_objectSpread({}, value), {}, {
                                                    inherit: false,
                                                    style
                                                }));
                                                setIsOpen(false);
                                            },
                                            children: style === "none" ? (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("None") : null
                                        }, style);
                                    }))
                                }, group[0]);
                            }))
                        })
                    }) ]
                }), !value.inherit && value.style !== "none" && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(_color_picker__WEBPACK_IMPORTED_MODULE_4__["default"], {
                    options: {
                        alpha: true,
                        colors
                    },
                    value: colorValues,
                    onChange: function onChange(c) {
                        _onChange(_objectSpread(_objectSpread({}, value), c));
                    }
                }) ]
            });
        };
        Border.renderingConfig = {
            design: "inline"
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Border;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(190);
        var _components_tooltip__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(251);
        var clsx__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9);
        var _utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4);
        var _index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var Preview = function(_Component) {
            _inherits(Preview, _Component);
            var _super = _createSuper(Preview);
            function Preview() {
                _classCallCheck(this, Preview);
                return _super.apply(this, arguments);
            }
            _createClass(Preview, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, palette = _this$props.palette, labels = _this$props.labels, className = _this$props.className;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_3__["default"])("colors", className),
                        children: Object.keys(palette).map((function(color) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                className: "preview",
                                style: {
                                    color: palette[color]
                                },
                                children: labels ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_components_tooltip__WEBPACK_IMPORTED_MODULE_2__["default"], {
                                    content: labels[color],
                                    placement: "top",
                                    children: function children(_ref) {
                                        var props = _ref.props;
                                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", _objectSpread({
                                            className: "preview-inner"
                                        }, props));
                                    }
                                }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                    className: "preview-inner"
                                })
                            }, color);
                        }))
                    });
                }
            } ]);
            return Preview;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var PaletteList = function(_Component2) {
            _inherits(PaletteList, _Component2);
            var _super2 = _createSuper(PaletteList);
            function PaletteList() {
                _classCallCheck(this, PaletteList);
                return _super2.apply(this, arguments);
            }
            _createClass(PaletteList, [ {
                key: "render",
                value: function render() {
                    var _this$props2 = this.props, palettes = _this$props2.palettes, current = _this$props2.current, onChange = _this$props2.onChange;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                        className: "palette-list",
                        children: Object.keys(palettes).map((function(palette) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                                onClick: function onClick() {
                                    return onChange(palette);
                                },
                                className: (0, clsx__WEBPACK_IMPORTED_MODULE_3__["default"])("palette-item", {
                                    active: current === palette
                                }),
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                                    className: "palette-title",
                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("span", {
                                        children: (0, _utils__WEBPACK_IMPORTED_MODULE_4__.capitalize)(palette).replaceAll("-", " ")
                                    }), current === palette && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("span", {
                                        className: "dashicons dashicons-saved"
                                    }) ]
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(Preview, {
                                    palette: palettes[palette]
                                }) ]
                            }, palette);
                        }))
                    });
                }
            } ]);
            return PaletteList;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var ColorPalettes = function(_Component3) {
            _inherits(ColorPalettes, _Component3);
            var _super3 = _createSuper(ColorPalettes);
            function ColorPalettes() {
                _classCallCheck(this, ColorPalettes);
                return _super3.apply(this, arguments);
            }
            _createClass(ColorPalettes, [ {
                key: "render",
                value: function render() {
                    var _this$props3 = this.props, options = _this$props3.options, value = _this$props3.value, _onChange = _this$props3.onChange;
                    var palettes = options.palettes, maps = options.maps, labels = options.labels;
                    var palette = palettes[value] || Object.values(palettes)[0];
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_1__["default"], {
                        content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(PaletteList, {
                            current: value,
                            palettes,
                            onChange: function onChange(value) {
                                if (maps) {
                                    var _palette = palettes[value];
                                    Object.keys(maps).forEach((function(control) {
                                        var colorMap = maps[control];
                                        var colorValue = {};
                                        Object.keys(colorMap).forEach((function(color) {
                                            colorValue[color] = _palette[colorMap[color]] ? _palette[colorMap[color]] : _index__WEBPACK_IMPORTED_MODULE_5__.CSS_INITIAL_VALUE;
                                        }));
                                        _onChange(colorValue, control);
                                    }));
                                }
                                _onChange(value);
                            }
                        }),
                        children: function children(_ref2) {
                            var props = _ref2.props;
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", _objectSpread(_objectSpread({}, props), {}, {
                                className: "palette-preview",
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(Preview, {
                                    palette,
                                    labels
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("span", {
                                    className: "dashicons dashicons-arrow-down-alt2"
                                }) ]
                            }));
                        }
                    });
                }
            } ]);
            return ColorPalettes;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = ColorPalettes;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _components_numeric_input__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(269);
        var _components_units_list__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(78);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        var Spacing = function Spacing(_ref) {
            var value = _ref.value, options = _ref.options, onChange = _ref.onChange;
            value = value || {
                top: "0px",
                right: "0px",
                bottom: "0px",
                left: "0px"
            };
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(false), _useState2 = _slicedToArray(_useState, 2), isOpen = _useState2[0], setIsOpen = _useState2[1];
            var units = [ {
                unit: "px",
                step: 1
            }, {
                unit: "%",
                step: 1
            }, {
                unit: "em",
                step: .1
            }, {
                unit: "rem",
                step: .1
            }, {
                unit: "pt",
                step: 1
            } ];
            var withDefault = function withDefault(currentUnit, defaultUnit) {
                return units.find((function(_ref2) {
                    var unit = _ref2.unit;
                    return unit === currentUnit;
                })) ? currentUnit : currentUnit || units[0].unit;
            };
            var getLinkedLeader = function getLinkedLeader() {
                return [ "top", "right", "bottom", "left" ].find((function(v) {
                    return value[v] !== "auto";
                }));
            };
            var getCurrentUnit = function getCurrentUnit() {
                return withDefault((value[getLinkedLeader()] || "").toString().replace(/[0-9]/g, "").replace("-", "").replace(/\./g, ""));
            };
            var getCurrentStep = function getCurrentStep() {
                var _units$find;
                var currentUnit = getCurrentUnit();
                return (_units$find = units.find((function(_ref3) {
                    var unit = _ref3.unit;
                    return unit === currentUnit;
                }))) === null || _units$find === void 0 ? void 0 : _units$find.step;
            };
            var getNumericValue = function getNumericValue(value) {
                var unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
                if (value === "auto") {
                    return value;
                }
                var v = parseFloat(value) === 0 ? 0 : parseFloat(value).toFixed(getCurrentStep() === 1 ? 0 : 1) || "";
                return "".concat(isNaN(v) ? 0 : v).concat(unit);
            };
            var handleChange = function handleChange(futureValue, position) {
                if (value.linked) {
                    onChange(_objectSpread(_objectSpread({}, value), {}, {
                        top: options.disabled && options.disabled["top"] ? value.top : getNumericValue(futureValue, getCurrentUnit()),
                        left: options.disabled && options.disabled["left"] ? value.left : getNumericValue(futureValue, getCurrentUnit()),
                        right: options.disabled && options.disabled["right"] ? value.right : getNumericValue(futureValue, getCurrentUnit()),
                        bottom: options.disabled && options.disabled["bottom"] ? value.bottom : getNumericValue(futureValue, getCurrentUnit())
                    }));
                    return;
                }
                onChange(_objectSpread(_objectSpread({}, value), {}, _defineProperty({}, position, getNumericValue(futureValue, getCurrentUnit()))));
            };
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("lotta-spacing", {
                    linked: value.linked
                }),
                children: [ [ "top", "right", "bottom", "left" ].map((function(side) {
                    var sideValue = getNumericValue(value[side]);
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("span", {
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_components_numeric_input__WEBPACK_IMPORTED_MODULE_2__["default"], _objectSpread({
                            placeholder: "",
                            step: getCurrentStep(),
                            inactive: options.disabled && options.disabled[side],
                            value: sideValue,
                            onChange: function onChange(v) {
                                return handleChange(v, side);
                            }
                        }, _objectSpread({
                            placeholder: ""
                        }, options.inputAttr))), options.autoToggle && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("button", {
                            className: "auto-num-toggle",
                            type: "button",
                            onClick: function onClick() {
                                handleChange(sideValue === "auto" ? 0 : "auto", side);
                            },
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("span", {
                                children: sideValue === "auto" ? "num" : "auto"
                            })
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("small", {
                            children: {
                                top: "Top",
                                bottom: "Bottom",
                                left: "Left",
                                right: "Right"
                            }[side]
                        }) ]
                    }, side);
                })), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("lotta-spacing-controls lotta-value-changer", {
                        active: isOpen
                    }),
                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("a", {
                        onClick: function onClick(e) {
                            e.preventDefault();
                            if (value.linked) {
                                onChange(_objectSpread(_objectSpread({}, value), {}, {
                                    linked: false
                                }));
                                return;
                            }
                            var futureValue = value[getLinkedLeader()];
                            onChange(_objectSpread(_objectSpread({}, value), {}, {
                                top: value.top !== "auto" ? futureValue : value.top,
                                left: value.left !== "auto" ? futureValue : value.left,
                                bottom: value.bottom !== "auto" ? futureValue : value.bottom,
                                right: value.right !== "auto" ? futureValue : value.right,
                                linked: true
                            }));
                        },
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("svg", {
                            width: "10",
                            height: "10",
                            viewBox: "0 0 15 15",
                            children: value.linked ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("path", {
                                d: "M12.2,5.5V4.7c0-2.6-2.1-4.7-4.7-4.7S2.8,2.1,2.8,4.7v0.8c-0.9,0-1.6,0.7-1.6,1.6v6.3c0,0.9,0.7,1.6,1.6,1.6h9.5c0.9,0,1.6-0.7,1.6-1.6V7.1C13.8,6.2,13.1,5.5,12.2,5.5z M10.7,5.5H4.3V4.7c0-1.8,1.4-3.2,3.2-3.2s3.2,1.4,3.2,3.2V5.5z"
                            }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("path", {
                                d: "M12.2,5.5h-1.6H9.9h-5H4.7l0-0.2C4.4,3.5,5.5,1.9,7.3,1.5c1.1-0.2,2.2,0.1,2.8,0.9l1.3-0.9c-1-1.1-2.6-1.8-4.3-1.5C4.5,0.5,2.8,2.9,3.2,5.5H2.8c-0.9,0-1.6,0.7-1.6,1.6v6.3c0,0.9,0.7,1.6,1.6,1.6h9.5c0.9,0,1.6-0.7,1.6-1.6V7.1C13.8,6.2,13.1,5.5,12.2,5.5z"
                            })
                        })
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("span", {
                        className: "lotta-value-divider"
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_components_units_list__WEBPACK_IMPORTED_MODULE_3__["default"], {
                        units,
                        isOpen,
                        toggleOpen: function toggleOpen() {
                            setIsOpen(!isOpen);
                        },
                        currentUnit: getCurrentUnit(),
                        onPickUnit: function onPickUnit(unit) {
                            onChange(_objectSpread(_objectSpread({}, value), {}, {
                                top: getNumericValue(value.top, unit),
                                left: getNumericValue(value.left, unit),
                                right: getNumericValue(value.right, unit),
                                bottom: getNumericValue(value.bottom, unit)
                            }));
                        }
                    }) ]
                }) ]
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Spacing;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var clsx__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
        var NumericInput = function NumericInput(props) {
            var value = props.value, _onBlur = props.onBlur, _onChange = props.onChange, inactive = props.inactive, _props$step = props.step, step = _props$step === void 0 ? 1 : _props$step, _props$placeholder = props.placeholder, placeholder = _props$placeholder === void 0 ? "Default" : _props$placeholder;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("input", {
                type: "text",
                value,
                step,
                onKeyDown: function onKeyDown(e) {
                    if ([ 46, 8, 9, 27, 13, 110, 190, 27 ].indexOf(e.keyCode) > -1 || e.keyCode == 65 && e.ctrlKey === true || e.keyCode == 109 || e.keyCode == 189 || e.keyCode == 173 || e.keyCode == 67 && e.ctrlKey === true || e.keyCode == 88 && e.ctrlKey === true || e.keyCode >= 35 && e.keyCode <= 39 && e.keyCode !== 38 && e.keyCode !== 40) {
                        return;
                    }
                    var valueForComputation = "__unset__";
                    if (value.toString().trim().length === 0) {
                        valueForComputation = 0;
                    } else {
                        var maybeValue = parseFloat(value);
                        if (maybeValue || maybeValue === 0) {
                            valueForComputation = maybeValue;
                        }
                    }
                    var actualStep = e.shiftKey ? step * 10 : step;
                    if (e.keyCode === 38 && value !== "__unset__") {
                        _onChange(valueForComputation + actualStep, true);
                    }
                    if (e.keyCode === 40 && value !== "__unset__") {
                        _onChange(valueForComputation - actualStep, true);
                    }
                    if ((e.shiftKey || e.keyCode < 48 || e.keyCode > 57) && (e.keyCode < 96 || e.keyCode > 105)) {
                        e.preventDefault();
                    }
                },
                onChange: function onChange(_ref) {
                    var value = _ref.target.value;
                    return _onChange(value);
                },
                placeholder,
                onBlur: function onBlur() {
                    return _onBlur && _onBlur;
                },
                className: (0, clsx__WEBPACK_IMPORTED_MODULE_0__["default"])({
                    inactive: value === "auto" || inactive
                })
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = NumericInput;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
        var Select = function Select(_ref) {
            var value = _ref.value, options = _ref.options, _onChange = _ref.onChange;
            var _options$choices = options.choices, choices = _options$choices === void 0 ? {} : _options$choices;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("select", {
                value,
                onChange: function onChange(ev) {
                    _onChange(ev.target.value);
                },
                children: Object.keys(choices).map((function(id) {
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("option", {
                        value: id,
                        children: choices[id]
                    }, id);
                }))
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Select;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _match_conditions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(272);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var RadioInput = function(_Component) {
            _inherits(RadioInput, _Component);
            var _super = _createSuper(RadioInput);
            function RadioInput() {
                _classCallCheck(this, RadioInput);
                return _super.apply(this, arguments);
            }
            _createClass(RadioInput, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, options = _this$props.options, value = _this$props.value, _onChange = _this$props.onChange;
                    var _options$inline = options.inline, inline = _options$inline === void 0 ? false : _options$inline;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", _objectSpread(_objectSpread(_objectSpread({
                        className: "lotta-radio-input"
                    }, inline ? _defineProperty({}, "data-inline", "") : {}), options.attr || {}), {}, {
                        children: Object.keys(options.choices).map((function(choice) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("label", {
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("input", {
                                    type: "radio",
                                    checked: choice === value,
                                    onChange: function onChange() {
                                        return _onChange(choice);
                                    }
                                }), options.choices[choice] ]
                            }, choice);
                        }))
                    }));
                }
            } ]);
            return RadioInput;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var ButtonsGroupRadio = function(_Component2) {
            _inherits(ButtonsGroupRadio, _Component2);
            var _super2 = _createSuper(ButtonsGroupRadio);
            function ButtonsGroupRadio() {
                _classCallCheck(this, ButtonsGroupRadio);
                return _super2.apply(this, arguments);
            }
            _createClass(ButtonsGroupRadio, [ {
                key: "render",
                value: function render() {
                    var _this$props2 = this.props, options = _this$props2.options, value = _this$props2.value, onChange = _this$props2.onChange;
                    var _options$inline2 = options.inline, inline = _options$inline2 === void 0 ? false : _options$inline2;
                    var matchingChoices = Object.keys(options.choices).filter((function(choice) {
                        if (!options.conditions) {
                            return true;
                        }
                        if (!options.conditions[choice]) {
                            return true;
                        }
                        return (0, _match_conditions__WEBPACK_IMPORTED_MODULE_1__.matchValuesWithCondition)((0, 
                        _match_conditions__WEBPACK_IMPORTED_MODULE_1__.normalizeCondition)(options.conditions[choice]), value);
                    }));
                    var normalizedValue = matchingChoices.includes(value) ? value : options["default"];
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("ul", _objectSpread(_objectSpread(_objectSpread({
                        className: "lotta-radio-input lotta-buttons-group"
                    }, inline ? _defineProperty({}, "data-inline", "") : {}), options.attr || {}), {}, {
                        children: matchingChoices.map((function(choice, index) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("li", {
                                className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                                    active: choice === normalizedValue
                                }),
                                onClick: function onClick() {
                                    return onChange(choice);
                                },
                                dangerouslySetInnerHTML: {
                                    __html: options.choices[choice]
                                }
                            }, choice);
                        }))
                    }));
                }
            } ]);
            return ButtonsGroupRadio;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var Radio = function Radio(props) {
            var options = props.options;
            if (options.view === "buttons") {
                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(ButtonsGroupRadio, _objectSpread({}, props));
            }
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(RadioInput, _objectSpread({}, props));
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Radio;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            matchValuesWithCondition: () => matchValuesWithCondition,
            normalizeCondition: () => normalizeCondition,
            opg: () => opg
        });
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _toArray(arr) {
            return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var opg = function opg(properties, obj, defaultValue) {
            var delimiter = "/";
            if (typeof properties == "string") {
                properties = properties.split(delimiter);
            } else {
                properties = [ properties ];
            }
            var property = properties.shift();
            if (!obj || typeof obj[property] == "undefined") {
                return defaultValue;
            }
            if (properties.length) {
                properties = properties.join(delimiter);
                return opg(properties, obj[property], defaultValue, delimiter);
            } else {
                return obj[property];
            }
        };
        var propertiesWithoutLast = function propertiesWithoutLast(properties) {
            var delimiter = "/";
            if (typeof properties == "string") {
                properties = properties.split(delimiter);
            }
            if (properties.length > 1) {
                properties.pop();
            }
            return properties;
        };
        var normalizeCondition = function normalizeCondition(conditionDescriptor) {
            if (!conditionDescriptor.all) {
                if (!conditionDescriptor.any) {
                    conditionDescriptor = {
                        all: conditionDescriptor
                    };
                }
            }
            return conditionDescriptor;
        };
        var matchValuesWithCondition = function matchValuesWithCondition(conditionDescriptor, inferedValuesForContext) {
            var conditionsObject = Object.values(conditionDescriptor)[0];
            var maybeGetMatcher = function maybeGetMatcher(matcher) {
                if (matcher.length > 4) {
                    return false;
                }
                if (matcher.indexOf("any") === 0) {
                    return "any";
                }
                if (matcher.indexOf("all") === 0) {
                    return "all";
                }
                return false;
            };
            var valuesToCheck = Object.keys(conditionsObject).map((function(singleOptionPath, index) {
                var maybeThat = Object.values(conditionsObject)[index];
                if (maybeGetMatcher(singleOptionPath) === "all" || maybeGetMatcher(singleOptionPath) === "any") {
                    return matchValuesWithCondition(_defineProperty({}, singleOptionPath, maybeThat), inferedValuesForContext);
                }
                return tryToMatchValueWithOptionPath(maybeThat, singleOptionPath, inferedValuesForContext);
            }));
            if (maybeGetMatcher(Object.keys(conditionDescriptor)[0]) === "all") {
                return valuesToCheck.every((function(v) {
                    return !!v;
                }));
            }
            if (maybeGetMatcher(Object.keys(conditionDescriptor)[0]) === "any") {
                return valuesToCheck.some((function(v) {
                    return !!v;
                }));
            }
        };
        function extractScalarValueFor(singleOptionPath, inferedValuesForContext) {
            var getAsInfered = function getAsInfered(path) {
                var values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : inferedValuesForContext;
                return opg(path, values);
            };
            if (singleOptionPath.indexOf(":") > -1) {
                var value = null;
                (function(thing, cb) {
                    return cb(thing);
                })(singleOptionPath.split(":"), (function(_ref) {
                    var _ref2 = _toArray(_ref), singleOptionPath = _ref2[0], matcher = _ref2.slice(1);
                    matcher = matcher.join(":");
                    if (matcher === "visibility") {
                        value = getAsInfered(singleOptionPath, _objectSpread(_objectSpread({}, inferedValuesForContext), {}, _defineProperty({}, propertiesWithoutLast(singleOptionPath), opg(propertiesWithoutLast(singleOptionPath), inferedValuesForContext)[inferedValuesForContext.wp_customizer_current_view] ? "yes" : "no")));
                    }
                    if (matcher === "responsive") {
                        value = getAsInfered(singleOptionPath, _objectSpread(_objectSpread({}, inferedValuesForContext), {}, _defineProperty({}, propertiesWithoutLast(singleOptionPath), opg(propertiesWithoutLast(singleOptionPath), inferedValuesForContext)[inferedValuesForContext.wp_customizer_current_view] || opg(propertiesWithoutLast(singleOptionPath), inferedValuesForContext))));
                    }
                    if (matcher === "truthy") {
                        value = !!getAsInfered(singleOptionPath) ? "yes" : "no";
                    }
                    if (matcher.indexOf("array-ids:") > -1) {
                        var _matcher$split = matcher.split(":"), _matcher$split2 = _slicedToArray(_matcher$split, 3), _ = _matcher$split2[0], id = _matcher$split2[1], path = _matcher$split2[2];
                        var _properValue = getAsInfered(singleOptionPath).find((function(v) {
                            return v.id === id;
                        }));
                        value = !_properValue ? "no" : opg(path, _properValue) || "no";
                    }
                    if (matcher.indexOf("json:") > -1) {
                        value = getAsInfered("".concat(singleOptionPath, "/").concat(matcher.split(":")[1])).toString();
                    }
                    if (matcher === "array_length") {
                        var _properValue2 = getAsInfered(singleOptionPath);
                        value = (_properValue2 || []).length.toString();
                    }
                    if (!value) {
                        throw new Error("Unknown matcher received. Please verify for typos. The received matcher: ".concat(matcher, "."));
                    }
                }));
                if (value) {
                    return value;
                } else {
                    singleOptionPath = singleOptionPath.split(":")[0];
                }
            }
            var properValue = getAsInfered(singleOptionPath);
            if (!properValue) return false;
            if (properValue.desktop) {
                return properValue;
            }
            return properValue.toString();
        }
        function tryToMatchValueWithOptionPath(maybeThat, singleOptionPath, inferedValuesForContext) {
            var properValue = extractScalarValueFor(singleOptionPath, inferedValuesForContext);
            if (maybeThat && maybeThat.toString() && maybeThat.toString().indexOf("~") === 0) {
                var toMatch = maybeThat.replace("~", "");
                if (properValue.desktop) {
                    return properValue.desktop === toMatch || properValue.tablet === toMatch || properValue.mobile === toMatch;
                }
                return properValue === toMatch;
            }
            properValue = properValue.toString();
            maybeThat = maybeThat.toString();
            if (!properValue) return false;
            if (maybeThat.indexOf("|") > -1) {
                if (maybeThat.indexOf("!") === 0) {
                    return maybeThat.substring(1).split("|").map((function(el) {
                        return el.trim();
                    })).includes(properValue.trim()) === -1;
                } else {
                    return maybeThat.split("|").map((function(el) {
                        return el.trim();
                    })).indexOf(properValue.trim()) > -1;
                }
            }
            if (maybeThat.indexOf("!") === 0) {
                return properValue !== maybeThat.substring(1).trim();
            }
            if (maybeThat.indexOf("*") === 0) {
                return properValue.indexOf(maybeThat.trim().substring(1).trim()) > -1;
            }
            return properValue === maybeThat.trim();
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => ImageRadio
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _components_tooltip__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(251);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var ImageRadio = function(_Component) {
            _inherits(ImageRadio, _Component);
            var _super = _createSuper(ImageRadio);
            function ImageRadio() {
                _classCallCheck(this, ImageRadio);
                return _super.apply(this, arguments);
            }
            _createClass(ImageRadio, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, options = _this$props.options, value = _this$props.value, onChange = _this$props.onChange;
                    var _ref = _objectSpread({}, options.attr || {}), attr = _extends({}, _ref);
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("ul", _objectSpread(_objectSpread({}, attr), {}, {
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])({
                            "lotta-image-radio": !options.inline,
                            "lotta-radio-input lotta-buttons-group": options.inline
                        }),
                        children: Object.keys(options.choices).map((function(choice) {
                            return _objectSpread({
                                key: choice
                            }, options.choices[choice]);
                        })).map((function(choice) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("li", {
                                onClick: function onClick() {
                                    return !choice.disabled && onChange(choice.key);
                                },
                                className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])({
                                    disabled: !!choice.disabled,
                                    active: choice.key === value
                                }),
                                children: [ choice.title ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_components_tooltip__WEBPACK_IMPORTED_MODULE_2__["default"], {
                                    content: choice.title,
                                    children: function children(_ref2) {
                                        var props = _ref2.props;
                                        return choice.src.indexOf("<svg") === -1 ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("img", _objectSpread(_objectSpread({}, props), {}, {
                                            alt: choice.title,
                                            src: choice.src
                                        })) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", _objectSpread(_objectSpread({}, props), {}, {
                                            dangerouslySetInnerHTML: {
                                                __html: choice.src
                                            }
                                        }));
                                    }
                                }) : choice.src.indexOf("<svg") === -1 ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("img", {
                                    alt: choice.title,
                                    src: choice.src
                                }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                                    dangerouslySetInnerHTML: {
                                        __html: choice.src
                                    }
                                }), choice.mask && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                                    className: "mask",
                                    children: choice.mask
                                }) ]
                            }, choice.key);
                        }))
                    }));
                }
            } ]);
            return ImageRadio;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
        var Separator = function Separator(_ref) {
            var options = _ref.options;
            var spacing = options.spacing, style = options.style, size = options.size;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("div", {
                className: "lotta-separator",
                style: {
                    padding: spacing ? "".concat(spacing, " 0") : 0
                },
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("div", {
                    style: {
                        borderBottomStyle: style || "dashed",
                        borderBottomSize: size || "1px"
                    }
                })
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Separator;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Tabs
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Tabs = function(_Component) {
            _inherits(Tabs, _Component);
            var _super = _createSuper(Tabs);
            function Tabs() {
                var _this;
                _classCallCheck(this, Tabs);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    active: _this.props.options.active
                });
                return _this;
            }
            _createClass(Tabs, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, options = _this$props.options, settings = _this$props.settings, _onChange = _this$props.onChange;
                    if (!options.tabs) {
                        return null;
                    }
                    var active = options.tabs.find((function(tab) {
                        return tab.id === _this2.state.active;
                    }));
                    if (!active || !active.controls) {
                        return null;
                    }
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                        className: "lotta-tabs lotta-tabs-" + options.style,
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("ul", {
                            children: options.tabs.map((function(tab) {
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("li", {
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])({
                                        active: tab.id === _this2.state.active
                                    }),
                                    onClick: function onClick() {
                                        _this2.setState({
                                            active: tab.id
                                        });
                                    },
                                    children: tab.label
                                }, tab.id);
                            }))
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
                            className: "lotta-tab-content",
                            children: (0, _index__WEBPACK_IMPORTED_MODULE_2__.buildNestedControls)({
                                controls: active.controls,
                                settings,
                                onChange: function onChange(val, id, self) {
                                    _onChange(val, id);
                                    if (!self) {
                                        _this2.forceUpdate();
                                    }
                                }
                            })
                        }) ]
                    });
                }
            } ]);
            return Tabs;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        _defineProperty(Tabs, "disableRevert", true);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _icons__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(277);
        var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var Collapse = function(_Component) {
            _inherits(Collapse, _Component);
            var _super = _createSuper(Collapse);
            function Collapse(props) {
                var _this;
                _classCallCheck(this, Collapse);
                _this = _super.call(this, props);
                _this.state = {
                    isOpen: props.options.open
                };
                return _this;
            }
            _createClass(Collapse, [ {
                key: "setIsOpen",
                value: function setIsOpen(isOpen) {
                    this.setState({
                        isOpen
                    });
                }
            }, {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, options = _this$props.options, settings = _this$props.settings, _onChange = _this$props.onChange;
                    var isOpen = this.state.isOpen;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                        className: "lotta-collapse lotta-collapse-" + options.style,
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                            className: "lotta-collapse-header",
                            onClick: function onClick() {
                                return _this2.setIsOpen(!isOpen);
                            },
                            children: [ !isOpen ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.RightCaret, {}) : (0, 
                            react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.DownCaret, {}), (0, 
                            react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                                children: options.label
                            }) ]
                        }), isOpen && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
                            className: "lotta-collapse-content",
                            children: (0, _index__WEBPACK_IMPORTED_MODULE_2__.buildNestedControls)({
                                controls: options.controls,
                                settings,
                                onChange: function onChange(val, id, self) {
                                    _onChange(val, id);
                                    if (!self) {
                                        _this2.forceUpdate();
                                    }
                                }
                            })
                        }) ]
                    });
                }
            } ]);
            return Collapse;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Collapse;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            CircleXMark: () => CircleXMark,
            Column: () => Column,
            Cube: () => Cube,
            DownAngle: () => DownAngle,
            DownCaret: () => DownCaret,
            Move: () => Move,
            Plus: () => Plus,
            PlusSolid: () => PlusSolid,
            RightCaret: () => RightCaret,
            RotateLeft: () => RotateLeft,
            Row: () => Row
        });
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
        var Row = function Row(_ref) {
            var _ref$w = _ref.w, w = _ref$w === void 0 ? 14 : _ref$w, _ref$h = _ref.h, h = _ref$h === void 0 ? 14 : _ref$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 32 32",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M1.856 2.144c-0.512 0.512-0.64 1.184-0.64 1.984v23.744c0 0.8 0.256 1.472 0.8 1.984s1.184 0.8 1.984 0.8h24c0.8 0 1.472-0.256 2.016-0.8 0.512-0.512 0.8-1.184 0.8-1.984v-23.744c0-0.8-0.288-1.472-0.8-1.984-0.672-0.544-1.344-0.8-2.016-0.8h-24c-0.928-0.16-1.6 0.256-2.144 0.8M4 7.072h23.456v8.8h-23.456v-8.8M27.616 18.784v8.832h-23.616v-8.832h23.616z"
                })
            });
        };
        var Column = function Column(_ref2) {
            var _ref2$w = _ref2.w, w = _ref2$w === void 0 ? 14 : _ref2$w, _ref2$h = _ref2.h, h = _ref2$h === void 0 ? 14 : _ref2$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 32 32",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M30.656 4.128c0-0.8-0.256-1.472-0.8-1.984-0.512-0.544-1.184-0.8-1.984-0.8h-23.872c-0.672 0-1.344 0.256-1.856 0.8-0.544 0.512-0.8 1.184-0.8 1.984v23.872c0 0.8 0.256 1.344 0.8 1.856 0.512 0.544 1.184 0.8 1.856 0.8h23.872c0.8 0 1.472-0.256 1.984-0.8 0.544-0.512 0.8-1.184 0.8-1.856v-23.872M4.256 7.2h10.272v20.544h-10.272v-20.544M17.472 27.744v-20.544h10.144v20.544h-10.144z"
                })
            });
        };
        var DownCaret = function DownCaret(_ref3) {
            var _ref3$w = _ref3.w, w = _ref3$w === void 0 ? 14 : _ref3$w, _ref3$h = _ref3.h, h = _ref3$h === void 0 ? 14 : _ref3$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 320 512",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M310.6 246.6l-127.1 128C176.4 380.9 168.2 384 160 384s-16.38-3.125-22.63-9.375l-127.1-128C.2244 237.5-2.516 223.7 2.438 211.8S19.07 192 32 192h255.1c12.94 0 24.62 7.781 29.58 19.75S319.8 237.5 310.6 246.6z"
                })
            });
        };
        var DownAngle = function DownAngle(_ref4) {
            var _ref4$w = _ref4.w, w = _ref4$w === void 0 ? 14 : _ref4$w, _ref4$h = _ref4.h, h = _ref4$h === void 0 ? 14 : _ref4$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 384 512",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M192 384c-8.188 0-16.38-3.125-22.62-9.375l-160-160c-12.5-12.5-12.5-32.75 0-45.25s32.75-12.5 45.25 0L192 306.8l137.4-137.4c12.5-12.5 32.75-12.5 45.25 0s12.5 32.75 0 45.25l-160 160C208.4 380.9 200.2 384 192 384z"
                })
            });
        };
        var RightCaret = function RightCaret(_ref5) {
            var _ref5$w = _ref5.w, w = _ref5$w === void 0 ? 14 : _ref5$w, _ref5$h = _ref5.h, h = _ref5$h === void 0 ? 14 : _ref5$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 256 512",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M118.6 105.4l128 127.1C252.9 239.6 256 247.8 256 255.1s-3.125 16.38-9.375 22.63l-128 127.1c-9.156 9.156-22.91 11.9-34.88 6.943S64 396.9 64 383.1V128c0-12.94 7.781-24.62 19.75-29.58S109.5 96.23 118.6 105.4z"
                })
            });
        };
        var Move = function Move(_ref6) {
            var _ref6$w = _ref6.w, w = _ref6$w === void 0 ? 14 : _ref6$w, _ref6$h = _ref6.h, h = _ref6$h === void 0 ? 14 : _ref6$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 512 512",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M512 255.1c0 8.188-3.125 16.41-9.375 22.66l-72 72C424.4 356.9 416.2 360 408 360c-18.28 0-32-14.95-32-32c0-8.188 3.125-16.38 9.375-22.62L402.8 288H288v114.8l17.38-17.38C311.6 379.1 319.8 376 328 376c18.28 0 32 14.95 32 32c0 8.188-3.125 16.38-9.375 22.62l-72 72C272.4 508.9 264.2 512 256 512s-16.38-3.125-22.62-9.375l-72-72C155.1 424.4 152 416.2 152 408c0-17.05 13.73-32 32-32c8.188 0 16.38 3.125 22.62 9.375L224 402.8V288H109.3l17.38 17.38C132.9 311.6 136 319.8 136 328c0 17.05-13.73 32-32 32c-8.188 0-16.38-3.125-22.62-9.375l-72-72C3.125 272.4 0 264.2 0 255.1s3.125-16.34 9.375-22.59l72-72C87.63 155.1 95.81 152 104 152c18.28 0 32 14.95 32 32c0 8.188-3.125 16.38-9.375 22.62L109.3 224H224V109.3L206.6 126.6C200.4 132.9 192.2 136 184 136c-18.28 0-32-14.95-32-32c0-8.188 3.125-16.38 9.375-22.62l72-72C239.6 3.125 247.8 0 256 0s16.38 3.125 22.62 9.375l72 72C356.9 87.63 360 95.81 360 104c0 17.05-13.73 32-32 32c-8.188 0-16.38-3.125-22.62-9.375L288 109.3V224h114.8l-17.38-17.38C379.1 200.4 376 192.2 376 184c0-17.05 13.73-32 32-32c8.188 0 16.38 3.125 22.62 9.375l72 72C508.9 239.6 512 247.8 512 255.1z"
                })
            });
        };
        var CircleXMark = function CircleXMark(_ref7) {
            var _ref7$w = _ref7.w, w = _ref7$w === void 0 ? 14 : _ref7$w, _ref7$h = _ref7.h, h = _ref7$h === void 0 ? 14 : _ref7$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 512 512",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M175 175C184.4 165.7 199.6 165.7 208.1 175L255.1 222.1L303 175C312.4 165.7 327.6 165.7 336.1 175C346.3 184.4 346.3 199.6 336.1 208.1L289.9 255.1L336.1 303C346.3 312.4 346.3 327.6 336.1 336.1C327.6 346.3 312.4 346.3 303 336.1L255.1 289.9L208.1 336.1C199.6 346.3 184.4 346.3 175 336.1C165.7 327.6 165.7 312.4 175 303L222.1 255.1L175 208.1C165.7 199.6 165.7 184.4 175 175V175zM512 256C512 397.4 397.4 512 256 512C114.6 512 0 397.4 0 256C0 114.6 114.6 0 256 0C397.4 0 512 114.6 512 256zM256 48C141.1 48 48 141.1 48 256C48 370.9 141.1 464 256 464C370.9 464 464 370.9 464 256C464 141.1 370.9 48 256 48z"
                })
            });
        };
        var Cube = function Cube(_ref8) {
            var _ref8$w = _ref8.w, w = _ref8$w === void 0 ? 14 : _ref8$w, _ref8$h = _ref8.h, h = _ref8$h === void 0 ? 14 : _ref8$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                viewBox: "0 0 512 512",
                width: w,
                height: h,
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M234.5 5.709C248.4 .7377 263.6 .7377 277.5 5.709L469.5 74.28C494.1 83.38 512 107.5 512 134.6V377.4C512 404.5 494.1 428.6 469.5 437.7L277.5 506.3C263.6 511.3 248.4 511.3 234.5 506.3L42.47 437.7C17 428.6 0 404.5 0 377.4V134.6C0 107.5 17 83.38 42.47 74.28L234.5 5.709zM256 65.98L82.34 128L256 190L429.7 128L256 65.98zM288 434.6L448 377.4V189.4L288 246.6V434.6z"
                })
            });
        };
        var PlusSolid = function PlusSolid(_ref9) {
            var _ref9$w = _ref9.w, w = _ref9$w === void 0 ? 14 : _ref9$w, _ref9$h = _ref9.h, h = _ref9$h === void 0 ? 14 : _ref9$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                width: w,
                height: h,
                viewBox: "0 0 512 512",
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M0 256C0 114.6 114.6 0 256 0C397.4 0 512 114.6 512 256C512 397.4 397.4 512 256 512C114.6 512 0 397.4 0 256zM256 368C269.3 368 280 357.3 280 344V280H344C357.3 280 368 269.3 368 256C368 242.7 357.3 232 344 232H280V168C280 154.7 269.3 144 256 144C242.7 144 232 154.7 232 168V232H168C154.7 232 144 242.7 144 256C144 269.3 154.7 280 168 280H232V344C232 357.3 242.7 368 256 368z"
                })
            });
        };
        var Plus = function Plus(_ref10) {
            var _ref10$w = _ref10.w, w = _ref10$w === void 0 ? 14 : _ref10$w, _ref10$h = _ref10.h, h = _ref10$h === void 0 ? 14 : _ref10$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                width: w,
                height: h,
                viewBox: "0 0 32 32",
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M16 30.816c-8.128 0-14.784-6.688-14.784-14.816s6.656-14.816 14.784-14.816 14.816 6.688 14.816 14.816-6.688 14.816-14.816 14.816zM16 27.872c6.528 0 11.872-5.344 11.872-11.872s-5.344-11.872-11.872-11.872-11.872 5.344-11.872 11.872 5.344 11.872 11.872 11.872zM14.528 14.528v-5.6c0-0.8 0.672-1.472 1.472-1.472s1.472 0.672 1.472 1.472v5.6h5.6c0.8 0 1.472 0.672 1.472 1.472s-0.672 1.472-1.472 1.472h-5.6v5.6c0 0.8-0.672 1.472-1.472 1.472s-1.472-0.672-1.472-1.472v-5.6h-5.6c-0.8 0-1.472-0.672-1.472-1.472s0.672-1.472 1.472-1.472h5.6z"
                })
            });
        };
        var RotateLeft = function RotateLeft(_ref11) {
            var _ref11$w = _ref11.w, w = _ref11$w === void 0 ? 14 : _ref11$w, _ref11$h = _ref11.h, h = _ref11$h === void 0 ? 14 : _ref11$h;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                width: w,
                height: h,
                viewBox: "0 0 512 512",
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", {
                    d: "M125.7 160H176c17.7 0 32 14.3 32 32s-14.3 32-32 32H48c-17.7 0-32-14.3-32-32V64c0-17.7 14.3-32 32-32s32 14.3 32 32v51.2L97.6 97.6c87.5-87.5 229.3-87.5 316.8 0s87.5 229.3 0 316.8s-229.3 87.5-316.8 0c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0c62.5 62.5 163.8 62.5 226.3 0s62.5-163.8 0-226.3s-163.8-62.5-226.3 0L125.7 160z"
                })
            });
        };
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            Layer: () => Layer,
            default: () => Layers
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(279);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(immutability_helper__WEBPACK_IMPORTED_MODULE_1__);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_2__);
        var _index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
        var deep_equal__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_4___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_4__);
        var clsx__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9);
        var _components_react_select__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(284);
        var _icons__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(277);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Layer = function(_Component) {
            _inherits(Layer, _Component);
            var _super = _createSuper(Layer);
            function Layer() {
                var _this;
                _classCallCheck(this, Layer);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    showControls: false
                });
                _defineProperty(_assertThisInitialized(_this), "toggleControls", (function() {
                    _this.setState({
                        showControls: !_this.state.showControls
                    });
                }));
                return _this;
            }
            _createClass(Layer, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, value = _this$props.value, layer = _this$props.layer, dynamic = _this$props.dynamic, onChange = _this$props.onChange, onNestedChange = _this$props.onNestedChange, onRemove = _this$props.onRemove, settings = _this$props.settings;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsxs)("li", {
                        className: "layer-wrapper",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsxs)("div", {
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_5__["default"])("layer", {
                                "layer-invisible": !value.visible
                            }),
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("button", {
                                type: "button",
                                className: "layer-visibility",
                                onClick: function onClick() {
                                    onChange(_objectSpread(_objectSpread({}, value), {}, {
                                        visible: !value.visible
                                    }));
                                },
                                children: value.visible ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("svg", {
                                    xmlns: "http://www.w3.org/2000/svg",
                                    viewBox: "0 0 576 512",
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("path", {
                                        d: "M288 144a110.94 110.94 0 0 0-31.24 5 55.4 55.4 0 0 1 7.24 27 56 56 0 0 1-56 56 55.4 55.4 0 0 1-27-7.24A111.71 111.71 0 1 0 288 144zm284.52 97.4C518.29 135.59 410.93 64 288 64S57.68 135.64 3.48 241.41a32.35 32.35 0 0 0 0 29.19C57.71 376.41 165.07 448 288 448s230.32-71.64 284.52-177.41a32.35 32.35 0 0 0 0-29.19zM288 400c-98.65 0-189.09-55-237.93-144C98.91 167 189.34 112 288 112s189.09 55 237.93 144C477.1 345 386.66 400 288 400z"
                                    })
                                }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("svg", {
                                    xmlns: "http://www.w3.org/2000/svg",
                                    viewBox: "0 0 640 512",
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("path", {
                                        d: "M634 471L36 3.51A16 16 0 0 0 13.51 6l-10 12.49A16 16 0 0 0 6 41l598 467.49a16 16 0 0 0 22.49-2.49l10-12.49A16 16 0 0 0 634 471zM296.79 146.47l134.79 105.38C429.36 191.91 380.48 144 320 144a112.26 112.26 0 0 0-23.21 2.47zm46.42 219.07L208.42 260.16C210.65 320.09 259.53 368 320 368a113 113 0 0 0 23.21-2.46zM320 112c98.65 0 189.09 55 237.93 144a285.53 285.53 0 0 1-44 60.2l37.74 29.5a333.7 333.7 0 0 0 52.9-75.11 32.35 32.35 0 0 0 0-29.19C550.29 135.59 442.93 64 320 64c-36.7 0-71.71 7-104.63 18.81l46.41 36.29c18.94-4.3 38.34-7.1 58.22-7.1zm0 288c-98.65 0-189.08-55-237.93-144a285.47 285.47 0 0 1 44.05-60.19l-37.74-29.5a333.6 333.6 0 0 0-52.89 75.1 32.35 32.35 0 0 0 0 29.19C89.72 376.41 197.08 448 320 448c36.7 0 71.71-7.05 104.63-18.81l-46.41-36.28C359.28 397.2 339.89 400 320 400z"
                                    })
                                })
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("div", {
                                className: "layer-label",
                                children: layer.label
                            }), dynamic && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("button", {
                                type: "button",
                                onClick: function onClick() {
                                    return onRemove(value.id);
                                },
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_7__.CircleXMark, {})
                            }), (layer.controls || []).length > 0 && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("button", {
                                type: "button",
                                disabled: !value.visible,
                                className: "layer-toggle",
                                onClick: this.toggleControls,
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("svg", {
                                    xmlns: "http://www.w3.org/2000/svg",
                                    viewBox: "0 0 320 512",
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("path", {
                                        d: "M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z"
                                    })
                                })
                            }) ]
                        }), (layer.controls || []).length > 0 && this.state.showControls && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("div", {
                            className: "layer-controls",
                            children: (0, _index__WEBPACK_IMPORTED_MODULE_3__.buildNestedControls)({
                                controls: layer.controls || [],
                                settings,
                                onChange: function onChange(val, id, self) {
                                    onNestedChange(val, id);
                                    if (!self) {
                                        _this2.forceUpdate();
                                    }
                                }
                            })
                        }) ]
                    }, value.id);
                }
            } ]);
            return Layer;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var Layers = function(_Component2) {
            _inherits(Layers, _Component2);
            var _super2 = _createSuper(Layers);
            function Layers() {
                var _this3;
                _classCallCheck(this, Layers);
                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                    args[_key2] = arguments[_key2];
                }
                _this3 = _super2.call.apply(_super2, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this3), "state", {
                    selected: ""
                });
                return _this3;
            }
            _createClass(Layers, [ {
                key: "render",
                value: function render() {
                    var _this4 = this;
                    var _this$props2 = this.props, value = _this$props2.value, _onChange = _this$props2.onChange, settings = _this$props2.settings;
                    var _this$props$options = this.props.options, layers = _this$props$options.layers, dynamic = _this$props$options.dynamic;
                    var items = value;
                    if (!dynamic) {
                        Object.keys(layers).forEach((function(layer) {
                            if (items.findIndex((function(i) {
                                return i.id === layer;
                            })) === -1) {
                                items = immutability_helper__WEBPACK_IMPORTED_MODULE_1___default()(items, {
                                    $push: [ {
                                        id: layer,
                                        visible: false
                                    } ]
                                });
                            }
                        }));
                    }
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsxs)(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.Fragment, {
                        children: [ dynamic && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsxs)("div", {
                            className: "lotta-layers-dynamic-select",
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(_components_react_select__WEBPACK_IMPORTED_MODULE_6__["default"], {
                                filters: value.map((function(i) {
                                    return i.id;
                                })),
                                items: layers,
                                value: this.state.selected,
                                onSelect: function onSelect(current) {
                                    _this4.setState({
                                        selected: current
                                    });
                                }
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("button", {
                                type: "button",
                                onClick: function onClick() {
                                    if (_this4.state.selected && value.findIndex((function(i) {
                                        return i.id === _this4.state.selected;
                                    })) === -1) {
                                        _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_1___default()(value, {
                                            $push: [ {
                                                id: _this4.state.selected,
                                                visible: true
                                            } ]
                                        }));
                                        _this4.setState({
                                            selected: ""
                                        });
                                    }
                                },
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_7__.PlusSolid, {})
                            }) ]
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_2__.ReactSortable, {
                            tag: "ul",
                            className: "lotta-layers",
                            handle: ".layer-label",
                            list: items,
                            setList: function setList(newItems) {
                                if (deep_equal__WEBPACK_IMPORTED_MODULE_4___default()(newItems, items)) {
                                    return;
                                }
                                _onChange(newItems);
                            },
                            children: items.map((function(item, index) {
                                var layer = layers[item.id];
                                if (!layer) {
                                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Fragment, {}, item.id);
                                }
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(Layer, {
                                    value: item,
                                    dynamic,
                                    settings,
                                    layer,
                                    onNestedChange: function onNestedChange(val, id) {
                                        _onChange(val, id);
                                    },
                                    onRemove: function onRemove(id) {
                                        _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_1___default()(value, {
                                            $splice: [ [ index, 1 ] ]
                                        }));
                                    },
                                    onChange: function onChange(newItem) {
                                        _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_1___default()(items, _defineProperty({}, index, {
                                            $set: newItem
                                        })));
                                    }
                                }, item.id);
                            }))
                        }) ]
                    });
                }
            } ]);
            return Layers;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (module, exports, __webpack_require__) => {
        "use strict";
        var process = __webpack_require__(56);
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        function stringifiable(obj) {
            return typeof obj === "object" && !("toString" in obj) ? Object.prototype.toString.call(obj).slice(8, -1) : obj;
        }
        var isProduction = typeof process === "object" && "development" === "production";
        function invariant(condition, message) {
            if (!condition) {
                if (isProduction) {
                    throw new Error("Invariant failed");
                }
                throw new Error(message());
            }
        }
        exports.invariant = invariant;
        var hasOwnProperty = Object.prototype.hasOwnProperty;
        var splice = Array.prototype.splice;
        var toString = Object.prototype.toString;
        function type(obj) {
            return toString.call(obj).slice(8, -1);
        }
        var assign = Object.assign || function(target, source) {
            getAllKeys(source).forEach((function(key) {
                if (hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }));
            return target;
        };
        var getAllKeys = typeof Object.getOwnPropertySymbols === "function" ? function(obj) {
            return Object.keys(obj).concat(Object.getOwnPropertySymbols(obj));
        } : function(obj) {
            return Object.keys(obj);
        };
        function copy(object) {
            return Array.isArray(object) ? assign(object.constructor(object.length), object) : type(object) === "Map" ? new Map(object) : type(object) === "Set" ? new Set(object) : object && typeof object === "object" ? assign(Object.create(Object.getPrototypeOf(object)), object) : object;
        }
        var Context = function() {
            function Context() {
                this.commands = assign({}, defaultCommands);
                this.update = this.update.bind(this);
                this.update.extend = this.extend = this.extend.bind(this);
                this.update.isEquals = function(x, y) {
                    return x === y;
                };
                this.update.newContext = function() {
                    return (new Context).update;
                };
            }
            Object.defineProperty(Context.prototype, "isEquals", {
                get: function() {
                    return this.update.isEquals;
                },
                set: function(value) {
                    this.update.isEquals = value;
                },
                enumerable: true,
                configurable: true
            });
            Context.prototype.extend = function(directive, fn) {
                this.commands[directive] = fn;
            };
            Context.prototype.update = function(object, $spec) {
                var _this = this;
                var spec = typeof $spec === "function" ? {
                    $apply: $spec
                } : $spec;
                if (!(Array.isArray(object) && Array.isArray(spec))) {
                    invariant(!Array.isArray(spec), (function() {
                        return "update(): You provided an invalid spec to update(). The spec may " + "not contain an array except as the value of $set, $push, $unshift, " + "$splice or any custom command allowing an array value.";
                    }));
                }
                invariant(typeof spec === "object" && spec !== null, (function() {
                    return "update(): You provided an invalid spec to update(). The spec and " + "every included key path must be plain objects containing one of the " + ("following commands: " + Object.keys(_this.commands).join(", ") + ".");
                }));
                var nextObject = object;
                getAllKeys(spec).forEach((function(key) {
                    if (hasOwnProperty.call(_this.commands, key)) {
                        var objectWasNextObject = object === nextObject;
                        nextObject = _this.commands[key](spec[key], nextObject, spec, object);
                        if (objectWasNextObject && _this.isEquals(nextObject, object)) {
                            nextObject = object;
                        }
                    } else {
                        var nextValueForKey = type(object) === "Map" ? _this.update(object.get(key), spec[key]) : _this.update(object[key], spec[key]);
                        var nextObjectValue = type(nextObject) === "Map" ? nextObject.get(key) : nextObject[key];
                        if (!_this.isEquals(nextValueForKey, nextObjectValue) || typeof nextValueForKey === "undefined" && !hasOwnProperty.call(object, key)) {
                            if (nextObject === object) {
                                nextObject = copy(object);
                            }
                            if (type(nextObject) === "Map") {
                                nextObject.set(key, nextValueForKey);
                            } else {
                                nextObject[key] = nextValueForKey;
                            }
                        }
                    }
                }));
                return nextObject;
            };
            return Context;
        }();
        exports.Context = Context;
        var defaultCommands = {
            $push: function(value, nextObject, spec) {
                invariantPushAndUnshift(nextObject, spec, "$push");
                return value.length ? nextObject.concat(value) : nextObject;
            },
            $unshift: function(value, nextObject, spec) {
                invariantPushAndUnshift(nextObject, spec, "$unshift");
                return value.length ? value.concat(nextObject) : nextObject;
            },
            $splice: function(value, nextObject, spec, originalObject) {
                invariantSplices(nextObject, spec);
                value.forEach((function(args) {
                    invariantSplice(args);
                    if (nextObject === originalObject && args.length) {
                        nextObject = copy(originalObject);
                    }
                    splice.apply(nextObject, args);
                }));
                return nextObject;
            },
            $set: function(value, _nextObject, spec) {
                invariantSet(spec);
                return value;
            },
            $toggle: function(targets, nextObject) {
                invariantSpecArray(targets, "$toggle");
                var nextObjectCopy = targets.length ? copy(nextObject) : nextObject;
                targets.forEach((function(target) {
                    nextObjectCopy[target] = !nextObject[target];
                }));
                return nextObjectCopy;
            },
            $unset: function(value, nextObject, _spec, originalObject) {
                invariantSpecArray(value, "$unset");
                value.forEach((function(key) {
                    if (Object.hasOwnProperty.call(nextObject, key)) {
                        if (nextObject === originalObject) {
                            nextObject = copy(originalObject);
                        }
                        delete nextObject[key];
                    }
                }));
                return nextObject;
            },
            $add: function(values, nextObject, _spec, originalObject) {
                invariantMapOrSet(nextObject, "$add");
                invariantSpecArray(values, "$add");
                if (type(nextObject) === "Map") {
                    values.forEach((function(_a) {
                        var key = _a[0], value = _a[1];
                        if (nextObject === originalObject && nextObject.get(key) !== value) {
                            nextObject = copy(originalObject);
                        }
                        nextObject.set(key, value);
                    }));
                } else {
                    values.forEach((function(value) {
                        if (nextObject === originalObject && !nextObject.has(value)) {
                            nextObject = copy(originalObject);
                        }
                        nextObject.add(value);
                    }));
                }
                return nextObject;
            },
            $remove: function(value, nextObject, _spec, originalObject) {
                invariantMapOrSet(nextObject, "$remove");
                invariantSpecArray(value, "$remove");
                value.forEach((function(key) {
                    if (nextObject === originalObject && nextObject.has(key)) {
                        nextObject = copy(originalObject);
                    }
                    nextObject.delete(key);
                }));
                return nextObject;
            },
            $merge: function(value, nextObject, _spec, originalObject) {
                invariantMerge(nextObject, value);
                getAllKeys(value).forEach((function(key) {
                    if (value[key] !== nextObject[key]) {
                        if (nextObject === originalObject) {
                            nextObject = copy(originalObject);
                        }
                        nextObject[key] = value[key];
                    }
                }));
                return nextObject;
            },
            $apply: function(value, original) {
                invariantApply(value);
                return value(original);
            }
        };
        var defaultContext = new Context;
        exports.isEquals = defaultContext.update.isEquals;
        exports.extend = defaultContext.extend;
        exports["default"] = defaultContext.update;
        exports["default"]["default"] = module.exports = assign(exports.default, exports);
        function invariantPushAndUnshift(value, spec, command) {
            invariant(Array.isArray(value), (function() {
                return "update(): expected target of " + stringifiable(command) + " to be an array; got " + stringifiable(value) + ".";
            }));
            invariantSpecArray(spec[command], command);
        }
        function invariantSpecArray(spec, command) {
            invariant(Array.isArray(spec), (function() {
                return "update(): expected spec of " + stringifiable(command) + " to be an array; got " + stringifiable(spec) + ". " + "Did you forget to wrap your parameter in an array?";
            }));
        }
        function invariantSplices(value, spec) {
            invariant(Array.isArray(value), (function() {
                return "Expected $splice target to be an array; got " + stringifiable(value);
            }));
            invariantSplice(spec.$splice);
        }
        function invariantSplice(value) {
            invariant(Array.isArray(value), (function() {
                return "update(): expected spec of $splice to be an array of arrays; got " + stringifiable(value) + ". " + "Did you forget to wrap your parameters in an array?";
            }));
        }
        function invariantApply(fn) {
            invariant(typeof fn === "function", (function() {
                return "update(): expected spec of $apply to be a function; got " + stringifiable(fn) + ".";
            }));
        }
        function invariantSet(spec) {
            invariant(Object.keys(spec).length === 1, (function() {
                return "Cannot have more than one key in an object with $set";
            }));
        }
        function invariantMerge(target, specValue) {
            invariant(specValue && typeof specValue === "object", (function() {
                return "update(): $merge expects a spec of type 'object'; got " + stringifiable(specValue);
            }));
            invariant(target && typeof target === "object", (function() {
                return "update(): $merge expects a target of type 'object'; got " + stringifiable(target);
            }));
        }
        function invariantMapOrSet(target, command) {
            var typeOfTarget = type(target);
            invariant(typeOfTarget === "Map" || typeOfTarget === "Set", (function() {
                return "update(): " + stringifiable(command) + " expects a target of type Set or Map; got " + stringifiable(typeOfTarget);
            }));
        }
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        var $8zHUo$sortablejs = __webpack_require__(281);
        var $8zHUo$classnames = __webpack_require__(282);
        var $8zHUo$react = __webpack_require__(12);
        var $8zHUo$tinyinvariant = __webpack_require__(283);
        function $parcel$interopDefault(a) {
            return a && a.__esModule ? a.default : a;
        }
        function $parcel$export(e, n, v, s) {
            Object.defineProperty(e, n, {
                get: v,
                set: s,
                enumerable: true,
                configurable: true
            });
        }
        function $parcel$exportWildcard(dest, source) {
            Object.keys(source).forEach((function(key) {
                if (key === "default" || key === "__esModule" || dest.hasOwnProperty(key)) {
                    return;
                }
                Object.defineProperty(dest, key, {
                    enumerable: true,
                    get: function get() {
                        return source[key];
                    }
                });
            }));
            return dest;
        }
        $parcel$export(module.exports, "Sortable", (() => $882b6d93070905b3$re_export$Sortable));
        $parcel$export(module.exports, "Direction", (() => $882b6d93070905b3$re_export$Direction));
        $parcel$export(module.exports, "DOMRect", (() => $882b6d93070905b3$re_export$DOMRect));
        $parcel$export(module.exports, "GroupOptions", (() => $882b6d93070905b3$re_export$GroupOptions));
        $parcel$export(module.exports, "MoveEvent", (() => $882b6d93070905b3$re_export$MoveEvent));
        $parcel$export(module.exports, "Options", (() => $882b6d93070905b3$re_export$Options));
        $parcel$export(module.exports, "PullResult", (() => $882b6d93070905b3$re_export$PullResult));
        $parcel$export(module.exports, "PutResult", (() => $882b6d93070905b3$re_export$PutResult));
        $parcel$export(module.exports, "SortableEvent", (() => $882b6d93070905b3$re_export$SortableEvent));
        $parcel$export(module.exports, "SortableOptions", (() => $882b6d93070905b3$re_export$SortableOptions));
        $parcel$export(module.exports, "Utils", (() => $882b6d93070905b3$re_export$Utils));
        $parcel$export(module.exports, "ReactSortable", (() => $7fe8e3ea572bda7a$export$11bbed9ee0012c13));
        function $eb03e74f8f7db1f3$export$1d0aa160432dfea5(node) {
            if (node.parentElement !== null) node.parentElement.removeChild(node);
        }
        function $eb03e74f8f7db1f3$export$6d240faa51aa562f(parent, newChild, index) {
            const refChild = parent.children[index] || null;
            parent.insertBefore(newChild, refChild);
        }
        function $eb03e74f8f7db1f3$export$d7d742816c28cf91(customs) {
            $eb03e74f8f7db1f3$export$77f49a256021c8de(customs);
            $eb03e74f8f7db1f3$export$a6177d5829f70ebc(customs);
        }
        function $eb03e74f8f7db1f3$export$77f49a256021c8de(customs) {
            customs.forEach((curr => $eb03e74f8f7db1f3$export$1d0aa160432dfea5(curr.element)));
        }
        function $eb03e74f8f7db1f3$export$a6177d5829f70ebc(customs) {
            customs.forEach((curr => {
                $eb03e74f8f7db1f3$export$6d240faa51aa562f(curr.parentElement, curr.element, curr.oldIndex);
            }));
        }
        function $eb03e74f8f7db1f3$export$4655efe700f887a(evt, list) {
            const mode = $eb03e74f8f7db1f3$export$1fc0f6205829e19c(evt);
            const parentElement = {
                parentElement: evt.from
            };
            let custom = [];
            switch (mode) {
              case "normal":
                const item = {
                    element: evt.item,
                    newIndex: evt.newIndex,
                    oldIndex: evt.oldIndex,
                    parentElement: evt.from
                };
                custom = [ item ];
                break;

              case "swap":
                const drag = {
                    element: evt.item,
                    oldIndex: evt.oldIndex,
                    newIndex: evt.newIndex,
                    ...parentElement
                };
                const swap = {
                    element: evt.swapItem,
                    oldIndex: evt.newIndex,
                    newIndex: evt.oldIndex,
                    ...parentElement
                };
                custom = [ drag, swap ];
                break;

              case "multidrag":
                custom = evt.oldIndicies.map(((curr, index) => ({
                    element: curr.multiDragElement,
                    oldIndex: curr.index,
                    newIndex: evt.newIndicies[index].index,
                    ...parentElement
                })));
                break;
            }
            const customs = $eb03e74f8f7db1f3$export$bc06a3af7dc65f53(custom, list);
            return customs;
        }
        function $eb03e74f8f7db1f3$export$c25cf8080bd305ec(normalized, list) {
            const a = $eb03e74f8f7db1f3$export$be2da95e6167b0bd(normalized, list);
            const b = $eb03e74f8f7db1f3$export$eca851ee65ae17e4(normalized, a);
            return b;
        }
        function $eb03e74f8f7db1f3$export$be2da95e6167b0bd(normalized, list) {
            const newList = [ ...list ];
            normalized.concat().reverse().forEach((curr => newList.splice(curr.oldIndex, 1)));
            return newList;
        }
        function $eb03e74f8f7db1f3$export$eca851ee65ae17e4(normalized, list, evt, clone) {
            const newList = [ ...list ];
            normalized.forEach((curr => {
                const newItem = clone && evt && clone(curr.item, evt);
                newList.splice(curr.newIndex, 0, newItem || curr.item);
            }));
            return newList;
        }
        function $eb03e74f8f7db1f3$export$1fc0f6205829e19c(evt) {
            if (evt.oldIndicies && evt.oldIndicies.length > 0) return "multidrag";
            if (evt.swapItem) return "swap";
            return "normal";
        }
        function $eb03e74f8f7db1f3$export$bc06a3af7dc65f53(inputs, list) {
            const normalized = inputs.map((curr => ({
                ...curr,
                item: list[curr.oldIndex]
            }))).sort(((a, b) => a.oldIndex - b.oldIndex));
            return normalized;
        }
        function $eb03e74f8f7db1f3$export$7553c81e62e31b7e(props) {
            const {list, setList, children, tag, style, className, clone, onAdd, onChange, onChoose, onClone, onEnd, onFilter, onRemove, onSort, onStart, onUnchoose, onUpdate, onMove, onSpill, onSelect, onDeselect, ...options} = props;
            return options;
        }
        const $7fe8e3ea572bda7a$var$store = {
            dragging: null
        };
        class $7fe8e3ea572bda7a$export$11bbed9ee0012c13 extends(0, $8zHUo$react.Component){
            static defaultProps={
                clone: item => item
            };
            constructor(props) {
                super(props);
                this.ref = (0, $8zHUo$react.createRef)();
                const newList = [ ...props.list ].map((item => Object.assign(item, {
                    chosen: false,
                    selected: false
                })));
                props.setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
                (0, $parcel$interopDefault($8zHUo$tinyinvariant))(!props.plugins, `\nPlugins prop is no longer supported.\nInstead, mount it with "Sortable.mount(new MultiDrag())"\nPlease read the updated README.md at https://github.com/SortableJS/react-sortablejs.\n      `);
            }
            componentDidMount() {
                if (this.ref.current === null) return;
                const newOptions = this.makeOptions();
                (0, $parcel$interopDefault($8zHUo$sortablejs)).create(this.ref.current, newOptions);
            }
            componentDidUpdate(prevProps) {
                if (prevProps.disabled !== this.props.disabled && this.sortable) this.sortable.option("disabled", this.props.disabled);
            }
            render() {
                const {tag, style, className, id} = this.props;
                const classicProps = {
                    style,
                    className,
                    id
                };
                const newTag = !tag || tag === null ? "div" : tag;
                return (0, $8zHUo$react.createElement)(newTag, {
                    ref: this.ref,
                    ...classicProps
                }, this.getChildren());
            }
            getChildren() {
                const {children, dataIdAttr, selectedClass = "sortable-selected", chosenClass = "sortable-chosen", dragClass = "sortable-drag", fallbackClass = "sortable-falback", ghostClass = "sortable-ghost", swapClass = "sortable-swap-highlight", filter = "sortable-filter", list} = this.props;
                if (!children || children == null) return null;
                const dataid = dataIdAttr || "data-id";
                return (0, $8zHUo$react.Children).map(children, ((child, index) => {
                    if (child === undefined) return undefined;
                    const item = list[index] || {};
                    const {className: prevClassName} = child.props;
                    const filtered = typeof filter === "string" && {
                        [filter.replace(".", "")]: !!item.filtered
                    };
                    const className = (0, $parcel$interopDefault($8zHUo$classnames))(prevClassName, {
                        [selectedClass]: item.selected,
                        [chosenClass]: item.chosen,
                        ...filtered
                    });
                    return (0, $8zHUo$react.cloneElement)(child, {
                        [dataid]: child.key,
                        className
                    });
                }));
            }
            get sortable() {
                const el = this.ref.current;
                if (el === null) return null;
                const key = Object.keys(el).find((k => k.includes("Sortable")));
                if (!key) return null;
                return el[key];
            }
            makeOptions() {
                const DOMHandlers = [ "onAdd", "onChoose", "onDeselect", "onEnd", "onRemove", "onSelect", "onSpill", "onStart", "onUnchoose", "onUpdate" ];
                const NonDOMHandlers = [ "onChange", "onClone", "onFilter", "onSort" ];
                const newOptions = (0, $eb03e74f8f7db1f3$export$7553c81e62e31b7e)(this.props);
                DOMHandlers.forEach((name => newOptions[name] = this.prepareOnHandlerPropAndDOM(name)));
                NonDOMHandlers.forEach((name => newOptions[name] = this.prepareOnHandlerProp(name)));
                const onMove1 = (evt, originalEvt) => {
                    const {onMove} = this.props;
                    const defaultValue = evt.willInsertAfter || -1;
                    if (!onMove) return defaultValue;
                    const result = onMove(evt, originalEvt, this.sortable, $7fe8e3ea572bda7a$var$store);
                    if (typeof result === "undefined") return false;
                    return result;
                };
                return {
                    ...newOptions,
                    onMove: onMove1
                };
            }
            prepareOnHandlerPropAndDOM(evtName) {
                return evt => {
                    this.callOnHandlerProp(evt, evtName);
                    this[evtName](evt);
                };
            }
            prepareOnHandlerProp(evtName) {
                return evt => {
                    this.callOnHandlerProp(evt, evtName);
                };
            }
            callOnHandlerProp(evt, evtName) {
                const propEvent = this.props[evtName];
                if (propEvent) propEvent(evt, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onAdd(evt) {
                const {list, setList, clone} = this.props;
                const otherList = [ ...$7fe8e3ea572bda7a$var$store.dragging.props.list ];
                const customs = (0, $eb03e74f8f7db1f3$export$4655efe700f887a)(evt, otherList);
                (0, $eb03e74f8f7db1f3$export$77f49a256021c8de)(customs);
                const newList = (0, $eb03e74f8f7db1f3$export$eca851ee65ae17e4)(customs, list, evt, clone).map((item => Object.assign(item, {
                    selected: false
                })));
                setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onRemove(evt) {
                const {list, setList} = this.props;
                const mode = (0, $eb03e74f8f7db1f3$export$1fc0f6205829e19c)(evt);
                const customs = (0, $eb03e74f8f7db1f3$export$4655efe700f887a)(evt, list);
                (0, $eb03e74f8f7db1f3$export$a6177d5829f70ebc)(customs);
                let newList = [ ...list ];
                if (evt.pullMode !== "clone") newList = (0, $eb03e74f8f7db1f3$export$be2da95e6167b0bd)(customs, newList); else {
                    let customClones = customs;
                    switch (mode) {
                      case "multidrag":
                        customClones = customs.map(((item, index) => ({
                            ...item,
                            element: evt.clones[index]
                        })));
                        break;

                      case "normal":
                        customClones = customs.map((item => ({
                            ...item,
                            element: evt.clone
                        })));
                        break;

                      case "swap":
                      default:
                        (0, $parcel$interopDefault($8zHUo$tinyinvariant))(true, `mode "${mode}" cannot clone. Please remove "props.clone" from <ReactSortable/> when using the "${mode}" plugin`);
                    }
                    (0, $eb03e74f8f7db1f3$export$77f49a256021c8de)(customClones);
                    customs.forEach((curr => {
                        const index = curr.oldIndex;
                        const newItem = this.props.clone(curr.item, evt);
                        newList.splice(index, 1, newItem);
                    }));
                }
                newList = newList.map((item => Object.assign(item, {
                    selected: false
                })));
                setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onUpdate(evt) {
                const {list, setList} = this.props;
                const customs = (0, $eb03e74f8f7db1f3$export$4655efe700f887a)(evt, list);
                (0, $eb03e74f8f7db1f3$export$77f49a256021c8de)(customs);
                (0, $eb03e74f8f7db1f3$export$a6177d5829f70ebc)(customs);
                const newList = (0, $eb03e74f8f7db1f3$export$c25cf8080bd305ec)(customs, list);
                return setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onStart() {
                $7fe8e3ea572bda7a$var$store.dragging = this;
            }
            onEnd() {
                $7fe8e3ea572bda7a$var$store.dragging = null;
            }
            onChoose(evt) {
                const {list, setList} = this.props;
                const newList = list.map(((item, index) => {
                    let newItem = item;
                    if (index === evt.oldIndex) newItem = Object.assign(item, {
                        chosen: true
                    });
                    return newItem;
                }));
                setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onUnchoose(evt) {
                const {list, setList} = this.props;
                const newList = list.map(((item, index) => {
                    let newItem = item;
                    if (index === evt.oldIndex) newItem = Object.assign(newItem, {
                        chosen: false
                    });
                    return newItem;
                }));
                setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onSpill(evt) {
                const {removeOnSpill, revertOnSpill} = this.props;
                if (removeOnSpill && !revertOnSpill) (0, $eb03e74f8f7db1f3$export$1d0aa160432dfea5)(evt.item);
            }
            onSelect(evt) {
                const {list, setList} = this.props;
                const newList = list.map((item => Object.assign(item, {
                    selected: false
                })));
                evt.newIndicies.forEach((curr => {
                    const index = curr.index;
                    if (index === -1) {
                        console.log(`"${evt.type}" had indice of "${curr.index}", which is probably -1 and doesn't usually happen here.`);
                        console.log(evt);
                        return;
                    }
                    newList[index].selected = true;
                }));
                setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
            onDeselect(evt) {
                const {list, setList} = this.props;
                const newList = list.map((item => Object.assign(item, {
                    selected: false
                })));
                evt.newIndicies.forEach((curr => {
                    const index = curr.index;
                    if (index === -1) return;
                    newList[index].selected = true;
                }));
                setList(newList, this.sortable, $7fe8e3ea572bda7a$var$store);
            }
        }
        var $faefaad95e5fcca0$exports = {};
        $parcel$exportWildcard(module.exports, $faefaad95e5fcca0$exports);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            MultiDrag: () => MultiDragPlugin,
            Sortable: () => Sortable,
            Swap: () => SwapPlugin,
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        /**!
 * Sortable 1.15.0
 * @author	RubaXa   <trash@rubaxa.org>
 * @author	owenm    <owen23355@gmail.com>
 * @license MIT
 */        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly) {
                    symbols = symbols.filter((function(sym) {
                        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                    }));
                }
                keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread2(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                    ownKeys(Object(source), true).forEach((function(key) {
                        _defineProperty(target, key, source[key]);
                    }));
                } else if (Object.getOwnPropertyDescriptors) {
                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                    ownKeys(Object(source)).forEach((function(key) {
                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                    }));
                }
            }
            return target;
        }
        function _typeof(obj) {
            "@babel/helpers - typeof";
            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof = function(obj) {
                    return typeof obj;
                };
            } else {
                _typeof = function(obj) {
                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
                };
            }
            return _typeof(obj);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _extends() {
            _extends = Object.assign || 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);
        }
        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;
        }
        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;
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        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);
        }
        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;
        }
        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.");
        }
        var version = "1.15.0";
        function userAgent(pattern) {
            if (typeof window !== "undefined" && window.navigator) {
                return !!navigator.userAgent.match(pattern);
            }
        }
        var IE11OrLess = userAgent(/(?:Trident.*rv[ :]?11\.|msie|iemobile|Windows Phone)/i);
        var Edge = userAgent(/Edge/i);
        var FireFox = userAgent(/firefox/i);
        var Safari = userAgent(/safari/i) && !userAgent(/chrome/i) && !userAgent(/android/i);
        var IOS = userAgent(/iP(ad|od|hone)/i);
        var ChromeForAndroid = userAgent(/chrome/i) && userAgent(/android/i);
        var captureMode = {
            capture: false,
            passive: false
        };
        function on(el, event, fn) {
            el.addEventListener(event, fn, !IE11OrLess && captureMode);
        }
        function off(el, event, fn) {
            el.removeEventListener(event, fn, !IE11OrLess && captureMode);
        }
        function matches(el, selector) {
            if (!selector) return;
            selector[0] === ">" && (selector = selector.substring(1));
            if (el) {
                try {
                    if (el.matches) {
                        return el.matches(selector);
                    } else if (el.msMatchesSelector) {
                        return el.msMatchesSelector(selector);
                    } else if (el.webkitMatchesSelector) {
                        return el.webkitMatchesSelector(selector);
                    }
                } catch (_) {
                    return false;
                }
            }
            return false;
        }
        function getParentOrHost(el) {
            return el.host && el !== document && el.host.nodeType ? el.host : el.parentNode;
        }
        function closest(el, selector, ctx, includeCTX) {
            if (el) {
                ctx = ctx || document;
                do {
                    if (selector != null && (selector[0] === ">" ? el.parentNode === ctx && matches(el, selector) : matches(el, selector)) || includeCTX && el === ctx) {
                        return el;
                    }
                    if (el === ctx) break;
                } while (el = getParentOrHost(el));
            }
            return null;
        }
        var R_SPACE = /\s+/g;
        function toggleClass(el, name, state) {
            if (el && name) {
                if (el.classList) {
                    el.classList[state ? "add" : "remove"](name);
                } else {
                    var className = (" " + el.className + " ").replace(R_SPACE, " ").replace(" " + name + " ", " ");
                    el.className = (className + (state ? " " + name : "")).replace(R_SPACE, " ");
                }
            }
        }
        function css(el, prop, val) {
            var style = el && el.style;
            if (style) {
                if (val === void 0) {
                    if (document.defaultView && document.defaultView.getComputedStyle) {
                        val = document.defaultView.getComputedStyle(el, "");
                    } else if (el.currentStyle) {
                        val = el.currentStyle;
                    }
                    return prop === void 0 ? val : val[prop];
                } else {
                    if (!(prop in style) && prop.indexOf("webkit") === -1) {
                        prop = "-webkit-" + prop;
                    }
                    style[prop] = val + (typeof val === "string" ? "" : "px");
                }
            }
        }
        function matrix(el, selfOnly) {
            var appliedTransforms = "";
            if (typeof el === "string") {
                appliedTransforms = el;
            } else {
                do {
                    var transform = css(el, "transform");
                    if (transform && transform !== "none") {
                        appliedTransforms = transform + " " + appliedTransforms;
                    }
                } while (!selfOnly && (el = el.parentNode));
            }
            var matrixFn = window.DOMMatrix || window.WebKitCSSMatrix || window.CSSMatrix || window.MSCSSMatrix;
            return matrixFn && new matrixFn(appliedTransforms);
        }
        function find(ctx, tagName, iterator) {
            if (ctx) {
                var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;
                if (iterator) {
                    for (;i < n; i++) {
                        iterator(list[i], i);
                    }
                }
                return list;
            }
            return [];
        }
        function getWindowScrollingElement() {
            var scrollingElement = document.scrollingElement;
            if (scrollingElement) {
                return scrollingElement;
            } else {
                return document.documentElement;
            }
        }
        function getRect(el, relativeToContainingBlock, relativeToNonStaticParent, undoScale, container) {
            if (!el.getBoundingClientRect && el !== window) return;
            var elRect, top, left, bottom, right, height, width;
            if (el !== window && el.parentNode && el !== getWindowScrollingElement()) {
                elRect = el.getBoundingClientRect();
                top = elRect.top;
                left = elRect.left;
                bottom = elRect.bottom;
                right = elRect.right;
                height = elRect.height;
                width = elRect.width;
            } else {
                top = 0;
                left = 0;
                bottom = window.innerHeight;
                right = window.innerWidth;
                height = window.innerHeight;
                width = window.innerWidth;
            }
            if ((relativeToContainingBlock || relativeToNonStaticParent) && el !== window) {
                container = container || el.parentNode;
                if (!IE11OrLess) {
                    do {
                        if (container && container.getBoundingClientRect && (css(container, "transform") !== "none" || relativeToNonStaticParent && css(container, "position") !== "static")) {
                            var containerRect = container.getBoundingClientRect();
                            top -= containerRect.top + parseInt(css(container, "border-top-width"));
                            left -= containerRect.left + parseInt(css(container, "border-left-width"));
                            bottom = top + elRect.height;
                            right = left + elRect.width;
                            break;
                        }
                    } while (container = container.parentNode);
                }
            }
            if (undoScale && el !== window) {
                var elMatrix = matrix(container || el), scaleX = elMatrix && elMatrix.a, scaleY = elMatrix && elMatrix.d;
                if (elMatrix) {
                    top /= scaleY;
                    left /= scaleX;
                    width /= scaleX;
                    height /= scaleY;
                    bottom = top + height;
                    right = left + width;
                }
            }
            return {
                top,
                left,
                bottom,
                right,
                width,
                height
            };
        }
        function isScrolledPast(el, elSide, parentSide) {
            var parent = getParentAutoScrollElement(el, true), elSideVal = getRect(el)[elSide];
            while (parent) {
                var parentSideVal = getRect(parent)[parentSide], visible = void 0;
                if (parentSide === "top" || parentSide === "left") {
                    visible = elSideVal >= parentSideVal;
                } else {
                    visible = elSideVal <= parentSideVal;
                }
                if (!visible) return parent;
                if (parent === getWindowScrollingElement()) break;
                parent = getParentAutoScrollElement(parent, false);
            }
            return false;
        }
        function getChild(el, childNum, options, includeDragEl) {
            var currentChild = 0, i = 0, children = el.children;
            while (i < children.length) {
                if (children[i].style.display !== "none" && children[i] !== Sortable.ghost && (includeDragEl || children[i] !== Sortable.dragged) && closest(children[i], options.draggable, el, false)) {
                    if (currentChild === childNum) {
                        return children[i];
                    }
                    currentChild++;
                }
                i++;
            }
            return null;
        }
        function lastChild(el, selector) {
            var last = el.lastElementChild;
            while (last && (last === Sortable.ghost || css(last, "display") === "none" || selector && !matches(last, selector))) {
                last = last.previousElementSibling;
            }
            return last || null;
        }
        function index(el, selector) {
            var index = 0;
            if (!el || !el.parentNode) {
                return -1;
            }
            while (el = el.previousElementSibling) {
                if (el.nodeName.toUpperCase() !== "TEMPLATE" && el !== Sortable.clone && (!selector || matches(el, selector))) {
                    index++;
                }
            }
            return index;
        }
        function getRelativeScrollOffset(el) {
            var offsetLeft = 0, offsetTop = 0, winScroller = getWindowScrollingElement();
            if (el) {
                do {
                    var elMatrix = matrix(el), scaleX = elMatrix.a, scaleY = elMatrix.d;
                    offsetLeft += el.scrollLeft * scaleX;
                    offsetTop += el.scrollTop * scaleY;
                } while (el !== winScroller && (el = el.parentNode));
            }
            return [ offsetLeft, offsetTop ];
        }
        function indexOfObject(arr, obj) {
            for (var i in arr) {
                if (!arr.hasOwnProperty(i)) continue;
                for (var key in obj) {
                    if (obj.hasOwnProperty(key) && obj[key] === arr[i][key]) return Number(i);
                }
            }
            return -1;
        }
        function getParentAutoScrollElement(el, includeSelf) {
            if (!el || !el.getBoundingClientRect) return getWindowScrollingElement();
            var elem = el;
            var gotSelf = false;
            do {
                if (elem.clientWidth < elem.scrollWidth || elem.clientHeight < elem.scrollHeight) {
                    var elemCSS = css(elem);
                    if (elem.clientWidth < elem.scrollWidth && (elemCSS.overflowX == "auto" || elemCSS.overflowX == "scroll") || elem.clientHeight < elem.scrollHeight && (elemCSS.overflowY == "auto" || elemCSS.overflowY == "scroll")) {
                        if (!elem.getBoundingClientRect || elem === document.body) return getWindowScrollingElement();
                        if (gotSelf || includeSelf) return elem;
                        gotSelf = true;
                    }
                }
            } while (elem = elem.parentNode);
            return getWindowScrollingElement();
        }
        function extend(dst, src) {
            if (dst && src) {
                for (var key in src) {
                    if (src.hasOwnProperty(key)) {
                        dst[key] = src[key];
                    }
                }
            }
            return dst;
        }
        function isRectEqual(rect1, rect2) {
            return Math.round(rect1.top) === Math.round(rect2.top) && Math.round(rect1.left) === Math.round(rect2.left) && Math.round(rect1.height) === Math.round(rect2.height) && Math.round(rect1.width) === Math.round(rect2.width);
        }
        var _throttleTimeout;
        function throttle(callback, ms) {
            return function() {
                if (!_throttleTimeout) {
                    var args = arguments, _this = this;
                    if (args.length === 1) {
                        callback.call(_this, args[0]);
                    } else {
                        callback.apply(_this, args);
                    }
                    _throttleTimeout = setTimeout((function() {
                        _throttleTimeout = void 0;
                    }), ms);
                }
            };
        }
        function cancelThrottle() {
            clearTimeout(_throttleTimeout);
            _throttleTimeout = void 0;
        }
        function scrollBy(el, x, y) {
            el.scrollLeft += x;
            el.scrollTop += y;
        }
        function clone(el) {
            var Polymer = window.Polymer;
            var $ = window.jQuery || window.Zepto;
            if (Polymer && Polymer.dom) {
                return Polymer.dom(el).cloneNode(true);
            } else if ($) {
                return $(el).clone(true)[0];
            } else {
                return el.cloneNode(true);
            }
        }
        function setRect(el, rect) {
            css(el, "position", "absolute");
            css(el, "top", rect.top);
            css(el, "left", rect.left);
            css(el, "width", rect.width);
            css(el, "height", rect.height);
        }
        function unsetRect(el) {
            css(el, "position", "");
            css(el, "top", "");
            css(el, "left", "");
            css(el, "width", "");
            css(el, "height", "");
        }
        var expando = "Sortable" + (new Date).getTime();
        function AnimationStateManager() {
            var animationStates = [], animationCallbackId;
            return {
                captureAnimationState: function captureAnimationState() {
                    animationStates = [];
                    if (!this.options.animation) return;
                    var children = [].slice.call(this.el.children);
                    children.forEach((function(child) {
                        if (css(child, "display") === "none" || child === Sortable.ghost) return;
                        animationStates.push({
                            target: child,
                            rect: getRect(child)
                        });
                        var fromRect = _objectSpread2({}, animationStates[animationStates.length - 1].rect);
                        if (child.thisAnimationDuration) {
                            var childMatrix = matrix(child, true);
                            if (childMatrix) {
                                fromRect.top -= childMatrix.f;
                                fromRect.left -= childMatrix.e;
                            }
                        }
                        child.fromRect = fromRect;
                    }));
                },
                addAnimationState: function addAnimationState(state) {
                    animationStates.push(state);
                },
                removeAnimationState: function removeAnimationState(target) {
                    animationStates.splice(indexOfObject(animationStates, {
                        target
                    }), 1);
                },
                animateAll: function animateAll(callback) {
                    var _this = this;
                    if (!this.options.animation) {
                        clearTimeout(animationCallbackId);
                        if (typeof callback === "function") callback();
                        return;
                    }
                    var animating = false, animationTime = 0;
                    animationStates.forEach((function(state) {
                        var time = 0, target = state.target, fromRect = target.fromRect, toRect = getRect(target), prevFromRect = target.prevFromRect, prevToRect = target.prevToRect, animatingRect = state.rect, targetMatrix = matrix(target, true);
                        if (targetMatrix) {
                            toRect.top -= targetMatrix.f;
                            toRect.left -= targetMatrix.e;
                        }
                        target.toRect = toRect;
                        if (target.thisAnimationDuration) {
                            if (isRectEqual(prevFromRect, toRect) && !isRectEqual(fromRect, toRect) && (animatingRect.top - toRect.top) / (animatingRect.left - toRect.left) === (fromRect.top - toRect.top) / (fromRect.left - toRect.left)) {
                                time = calculateRealTime(animatingRect, prevFromRect, prevToRect, _this.options);
                            }
                        }
                        if (!isRectEqual(toRect, fromRect)) {
                            target.prevFromRect = fromRect;
                            target.prevToRect = toRect;
                            if (!time) {
                                time = _this.options.animation;
                            }
                            _this.animate(target, animatingRect, toRect, time);
                        }
                        if (time) {
                            animating = true;
                            animationTime = Math.max(animationTime, time);
                            clearTimeout(target.animationResetTimer);
                            target.animationResetTimer = setTimeout((function() {
                                target.animationTime = 0;
                                target.prevFromRect = null;
                                target.fromRect = null;
                                target.prevToRect = null;
                                target.thisAnimationDuration = null;
                            }), time);
                            target.thisAnimationDuration = time;
                        }
                    }));
                    clearTimeout(animationCallbackId);
                    if (!animating) {
                        if (typeof callback === "function") callback();
                    } else {
                        animationCallbackId = setTimeout((function() {
                            if (typeof callback === "function") callback();
                        }), animationTime);
                    }
                    animationStates = [];
                },
                animate: function animate(target, currentRect, toRect, duration) {
                    if (duration) {
                        css(target, "transition", "");
                        css(target, "transform", "");
                        var elMatrix = matrix(this.el), scaleX = elMatrix && elMatrix.a, scaleY = elMatrix && elMatrix.d, translateX = (currentRect.left - toRect.left) / (scaleX || 1), translateY = (currentRect.top - toRect.top) / (scaleY || 1);
                        target.animatingX = !!translateX;
                        target.animatingY = !!translateY;
                        css(target, "transform", "translate3d(" + translateX + "px," + translateY + "px,0)");
                        this.forRepaintDummy = repaint(target);
                        css(target, "transition", "transform " + duration + "ms" + (this.options.easing ? " " + this.options.easing : ""));
                        css(target, "transform", "translate3d(0,0,0)");
                        typeof target.animated === "number" && clearTimeout(target.animated);
                        target.animated = setTimeout((function() {
                            css(target, "transition", "");
                            css(target, "transform", "");
                            target.animated = false;
                            target.animatingX = false;
                            target.animatingY = false;
                        }), duration);
                    }
                }
            };
        }
        function repaint(target) {
            return target.offsetWidth;
        }
        function calculateRealTime(animatingRect, fromRect, toRect, options) {
            return Math.sqrt(Math.pow(fromRect.top - animatingRect.top, 2) + Math.pow(fromRect.left - animatingRect.left, 2)) / Math.sqrt(Math.pow(fromRect.top - toRect.top, 2) + Math.pow(fromRect.left - toRect.left, 2)) * options.animation;
        }
        var plugins = [];
        var defaults = {
            initializeByDefault: true
        };
        var PluginManager = {
            mount: function mount(plugin) {
                for (var option in defaults) {
                    if (defaults.hasOwnProperty(option) && !(option in plugin)) {
                        plugin[option] = defaults[option];
                    }
                }
                plugins.forEach((function(p) {
                    if (p.pluginName === plugin.pluginName) {
                        throw "Sortable: Cannot mount plugin ".concat(plugin.pluginName, " more than once");
                    }
                }));
                plugins.push(plugin);
            },
            pluginEvent: function pluginEvent(eventName, sortable, evt) {
                var _this = this;
                this.eventCanceled = false;
                evt.cancel = function() {
                    _this.eventCanceled = true;
                };
                var eventNameGlobal = eventName + "Global";
                plugins.forEach((function(plugin) {
                    if (!sortable[plugin.pluginName]) return;
                    if (sortable[plugin.pluginName][eventNameGlobal]) {
                        sortable[plugin.pluginName][eventNameGlobal](_objectSpread2({
                            sortable
                        }, evt));
                    }
                    if (sortable.options[plugin.pluginName] && sortable[plugin.pluginName][eventName]) {
                        sortable[plugin.pluginName][eventName](_objectSpread2({
                            sortable
                        }, evt));
                    }
                }));
            },
            initializePlugins: function initializePlugins(sortable, el, defaults, options) {
                plugins.forEach((function(plugin) {
                    var pluginName = plugin.pluginName;
                    if (!sortable.options[pluginName] && !plugin.initializeByDefault) return;
                    var initialized = new plugin(sortable, el, sortable.options);
                    initialized.sortable = sortable;
                    initialized.options = sortable.options;
                    sortable[pluginName] = initialized;
                    _extends(defaults, initialized.defaults);
                }));
                for (var option in sortable.options) {
                    if (!sortable.options.hasOwnProperty(option)) continue;
                    var modified = this.modifyOption(sortable, option, sortable.options[option]);
                    if (typeof modified !== "undefined") {
                        sortable.options[option] = modified;
                    }
                }
            },
            getEventProperties: function getEventProperties(name, sortable) {
                var eventProperties = {};
                plugins.forEach((function(plugin) {
                    if (typeof plugin.eventProperties !== "function") return;
                    _extends(eventProperties, plugin.eventProperties.call(sortable[plugin.pluginName], name));
                }));
                return eventProperties;
            },
            modifyOption: function modifyOption(sortable, name, value) {
                var modifiedValue;
                plugins.forEach((function(plugin) {
                    if (!sortable[plugin.pluginName]) return;
                    if (plugin.optionListeners && typeof plugin.optionListeners[name] === "function") {
                        modifiedValue = plugin.optionListeners[name].call(sortable[plugin.pluginName], value);
                    }
                }));
                return modifiedValue;
            }
        };
        function dispatchEvent(_ref) {
            var sortable = _ref.sortable, rootEl = _ref.rootEl, name = _ref.name, targetEl = _ref.targetEl, cloneEl = _ref.cloneEl, toEl = _ref.toEl, fromEl = _ref.fromEl, oldIndex = _ref.oldIndex, newIndex = _ref.newIndex, oldDraggableIndex = _ref.oldDraggableIndex, newDraggableIndex = _ref.newDraggableIndex, originalEvent = _ref.originalEvent, putSortable = _ref.putSortable, extraEventProperties = _ref.extraEventProperties;
            sortable = sortable || rootEl && rootEl[expando];
            if (!sortable) return;
            var evt, options = sortable.options, onName = "on" + name.charAt(0).toUpperCase() + name.substr(1);
            if (window.CustomEvent && !IE11OrLess && !Edge) {
                evt = new CustomEvent(name, {
                    bubbles: true,
                    cancelable: true
                });
            } else {
                evt = document.createEvent("Event");
                evt.initEvent(name, true, true);
            }
            evt.to = toEl || rootEl;
            evt.from = fromEl || rootEl;
            evt.item = targetEl || rootEl;
            evt.clone = cloneEl;
            evt.oldIndex = oldIndex;
            evt.newIndex = newIndex;
            evt.oldDraggableIndex = oldDraggableIndex;
            evt.newDraggableIndex = newDraggableIndex;
            evt.originalEvent = originalEvent;
            evt.pullMode = putSortable ? putSortable.lastPutMode : undefined;
            var allEventProperties = _objectSpread2(_objectSpread2({}, extraEventProperties), PluginManager.getEventProperties(name, sortable));
            for (var option in allEventProperties) {
                evt[option] = allEventProperties[option];
            }
            if (rootEl) {
                rootEl.dispatchEvent(evt);
            }
            if (options[onName]) {
                options[onName].call(sortable, evt);
            }
        }
        var _excluded = [ "evt" ];
        var pluginEvent = function pluginEvent(eventName, sortable) {
            var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, originalEvent = _ref.evt, data = _objectWithoutProperties(_ref, _excluded);
            PluginManager.pluginEvent.bind(Sortable)(eventName, sortable, _objectSpread2({
                dragEl,
                parentEl,
                ghostEl,
                rootEl,
                nextEl,
                lastDownEl,
                cloneEl,
                cloneHidden,
                dragStarted: moved,
                putSortable,
                activeSortable: Sortable.active,
                originalEvent,
                oldIndex,
                oldDraggableIndex,
                newIndex,
                newDraggableIndex,
                hideGhostForTarget: _hideGhostForTarget,
                unhideGhostForTarget: _unhideGhostForTarget,
                cloneNowHidden: function cloneNowHidden() {
                    cloneHidden = true;
                },
                cloneNowShown: function cloneNowShown() {
                    cloneHidden = false;
                },
                dispatchSortableEvent: function dispatchSortableEvent(name) {
                    _dispatchEvent({
                        sortable,
                        name,
                        originalEvent
                    });
                }
            }, data));
        };
        function _dispatchEvent(info) {
            dispatchEvent(_objectSpread2({
                putSortable,
                cloneEl,
                targetEl: dragEl,
                rootEl,
                oldIndex,
                oldDraggableIndex,
                newIndex,
                newDraggableIndex
            }, info));
        }
        var dragEl, parentEl, ghostEl, rootEl, nextEl, lastDownEl, cloneEl, cloneHidden, oldIndex, newIndex, oldDraggableIndex, newDraggableIndex, activeGroup, putSortable, awaitingDragStarted = false, ignoreNextClick = false, sortables = [], tapEvt, touchEvt, lastDx, lastDy, tapDistanceLeft, tapDistanceTop, moved, lastTarget, lastDirection, pastFirstInvertThresh = false, isCircumstantialInvert = false, targetMoveDistance, ghostRelativeParent, ghostRelativeParentInitialScroll = [], _silent = false, savedInputChecked = [];
        var documentExists = typeof document !== "undefined", PositionGhostAbsolutely = IOS, CSSFloatProperty = Edge || IE11OrLess ? "cssFloat" : "float", supportDraggable = documentExists && !ChromeForAndroid && !IOS && "draggable" in document.createElement("div"), supportCssPointerEvents = function() {
            if (!documentExists) return;
            if (IE11OrLess) {
                return false;
            }
            var el = document.createElement("x");
            el.style.cssText = "pointer-events:auto";
            return el.style.pointerEvents === "auto";
        }(), _detectDirection = function _detectDirection(el, options) {
            var elCSS = css(el), elWidth = parseInt(elCSS.width) - parseInt(elCSS.paddingLeft) - parseInt(elCSS.paddingRight) - parseInt(elCSS.borderLeftWidth) - parseInt(elCSS.borderRightWidth), child1 = getChild(el, 0, options), child2 = getChild(el, 1, options), firstChildCSS = child1 && css(child1), secondChildCSS = child2 && css(child2), firstChildWidth = firstChildCSS && parseInt(firstChildCSS.marginLeft) + parseInt(firstChildCSS.marginRight) + getRect(child1).width, secondChildWidth = secondChildCSS && parseInt(secondChildCSS.marginLeft) + parseInt(secondChildCSS.marginRight) + getRect(child2).width;
            if (elCSS.display === "flex") {
                return elCSS.flexDirection === "column" || elCSS.flexDirection === "column-reverse" ? "vertical" : "horizontal";
            }
            if (elCSS.display === "grid") {
                return elCSS.gridTemplateColumns.split(" ").length <= 1 ? "vertical" : "horizontal";
            }
            if (child1 && firstChildCSS["float"] && firstChildCSS["float"] !== "none") {
                var touchingSideChild2 = firstChildCSS["float"] === "left" ? "left" : "right";
                return child2 && (secondChildCSS.clear === "both" || secondChildCSS.clear === touchingSideChild2) ? "vertical" : "horizontal";
            }
            return child1 && (firstChildCSS.display === "block" || firstChildCSS.display === "flex" || firstChildCSS.display === "table" || firstChildCSS.display === "grid" || firstChildWidth >= elWidth && elCSS[CSSFloatProperty] === "none" || child2 && elCSS[CSSFloatProperty] === "none" && firstChildWidth + secondChildWidth > elWidth) ? "vertical" : "horizontal";
        }, _dragElInRowColumn = function _dragElInRowColumn(dragRect, targetRect, vertical) {
            var dragElS1Opp = vertical ? dragRect.left : dragRect.top, dragElS2Opp = vertical ? dragRect.right : dragRect.bottom, dragElOppLength = vertical ? dragRect.width : dragRect.height, targetS1Opp = vertical ? targetRect.left : targetRect.top, targetS2Opp = vertical ? targetRect.right : targetRect.bottom, targetOppLength = vertical ? targetRect.width : targetRect.height;
            return dragElS1Opp === targetS1Opp || dragElS2Opp === targetS2Opp || dragElS1Opp + dragElOppLength / 2 === targetS1Opp + targetOppLength / 2;
        }, _detectNearestEmptySortable = function _detectNearestEmptySortable(x, y) {
            var ret;
            sortables.some((function(sortable) {
                var threshold = sortable[expando].options.emptyInsertThreshold;
                if (!threshold || lastChild(sortable)) return;
                var rect = getRect(sortable), insideHorizontally = x >= rect.left - threshold && x <= rect.right + threshold, insideVertically = y >= rect.top - threshold && y <= rect.bottom + threshold;
                if (insideHorizontally && insideVertically) {
                    return ret = sortable;
                }
            }));
            return ret;
        }, _prepareGroup = function _prepareGroup(options) {
            function toFn(value, pull) {
                return function(to, from, dragEl, evt) {
                    var sameGroup = to.options.group.name && from.options.group.name && to.options.group.name === from.options.group.name;
                    if (value == null && (pull || sameGroup)) {
                        return true;
                    } else if (value == null || value === false) {
                        return false;
                    } else if (pull && value === "clone") {
                        return value;
                    } else if (typeof value === "function") {
                        return toFn(value(to, from, dragEl, evt), pull)(to, from, dragEl, evt);
                    } else {
                        var otherGroup = (pull ? to : from).options.group.name;
                        return value === true || typeof value === "string" && value === otherGroup || value.join && value.indexOf(otherGroup) > -1;
                    }
                };
            }
            var group = {};
            var originalGroup = options.group;
            if (!originalGroup || _typeof(originalGroup) != "object") {
                originalGroup = {
                    name: originalGroup
                };
            }
            group.name = originalGroup.name;
            group.checkPull = toFn(originalGroup.pull, true);
            group.checkPut = toFn(originalGroup.put);
            group.revertClone = originalGroup.revertClone;
            options.group = group;
        }, _hideGhostForTarget = function _hideGhostForTarget() {
            if (!supportCssPointerEvents && ghostEl) {
                css(ghostEl, "display", "none");
            }
        }, _unhideGhostForTarget = function _unhideGhostForTarget() {
            if (!supportCssPointerEvents && ghostEl) {
                css(ghostEl, "display", "");
            }
        };
        if (documentExists && !ChromeForAndroid) {
            document.addEventListener("click", (function(evt) {
                if (ignoreNextClick) {
                    evt.preventDefault();
                    evt.stopPropagation && evt.stopPropagation();
                    evt.stopImmediatePropagation && evt.stopImmediatePropagation();
                    ignoreNextClick = false;
                    return false;
                }
            }), true);
        }
        var nearestEmptyInsertDetectEvent = function nearestEmptyInsertDetectEvent(evt) {
            if (dragEl) {
                evt = evt.touches ? evt.touches[0] : evt;
                var nearest = _detectNearestEmptySortable(evt.clientX, evt.clientY);
                if (nearest) {
                    var event = {};
                    for (var i in evt) {
                        if (evt.hasOwnProperty(i)) {
                            event[i] = evt[i];
                        }
                    }
                    event.target = event.rootEl = nearest;
                    event.preventDefault = void 0;
                    event.stopPropagation = void 0;
                    nearest[expando]._onDragOver(event);
                }
            }
        };
        var _checkOutsideTargetEl = function _checkOutsideTargetEl(evt) {
            if (dragEl) {
                dragEl.parentNode[expando]._isOutsideThisEl(evt.target);
            }
        };
        function Sortable(el, options) {
            if (!(el && el.nodeType && el.nodeType === 1)) {
                throw "Sortable: `el` must be an HTMLElement, not ".concat({}.toString.call(el));
            }
            this.el = el;
            this.options = options = _extends({}, options);
            el[expando] = this;
            var defaults = {
                group: null,
                sort: true,
                disabled: false,
                store: null,
                handle: null,
                draggable: /^[uo]l$/i.test(el.nodeName) ? ">li" : ">*",
                swapThreshold: 1,
                invertSwap: false,
                invertedSwapThreshold: null,
                removeCloneOnHide: true,
                direction: function direction() {
                    return _detectDirection(el, this.options);
                },
                ghostClass: "sortable-ghost",
                chosenClass: "sortable-chosen",
                dragClass: "sortable-drag",
                ignore: "a, img",
                filter: null,
                preventOnFilter: true,
                animation: 0,
                easing: null,
                setData: function setData(dataTransfer, dragEl) {
                    dataTransfer.setData("Text", dragEl.textContent);
                },
                dropBubble: false,
                dragoverBubble: false,
                dataIdAttr: "data-id",
                delay: 0,
                delayOnTouchOnly: false,
                touchStartThreshold: (Number.parseInt ? Number : window).parseInt(window.devicePixelRatio, 10) || 1,
                forceFallback: false,
                fallbackClass: "sortable-fallback",
                fallbackOnBody: false,
                fallbackTolerance: 0,
                fallbackOffset: {
                    x: 0,
                    y: 0
                },
                supportPointer: Sortable.supportPointer !== false && "PointerEvent" in window && !Safari,
                emptyInsertThreshold: 5
            };
            PluginManager.initializePlugins(this, el, defaults);
            for (var name in defaults) {
                !(name in options) && (options[name] = defaults[name]);
            }
            _prepareGroup(options);
            for (var fn in this) {
                if (fn.charAt(0) === "_" && typeof this[fn] === "function") {
                    this[fn] = this[fn].bind(this);
                }
            }
            this.nativeDraggable = options.forceFallback ? false : supportDraggable;
            if (this.nativeDraggable) {
                this.options.touchStartThreshold = 1;
            }
            if (options.supportPointer) {
                on(el, "pointerdown", this._onTapStart);
            } else {
                on(el, "mousedown", this._onTapStart);
                on(el, "touchstart", this._onTapStart);
            }
            if (this.nativeDraggable) {
                on(el, "dragover", this);
                on(el, "dragenter", this);
            }
            sortables.push(this.el);
            options.store && options.store.get && this.sort(options.store.get(this) || []);
            _extends(this, AnimationStateManager());
        }
        Sortable.prototype = {
            constructor: Sortable,
            _isOutsideThisEl: function _isOutsideThisEl(target) {
                if (!this.el.contains(target) && target !== this.el) {
                    lastTarget = null;
                }
            },
            _getDirection: function _getDirection(evt, target) {
                return typeof this.options.direction === "function" ? this.options.direction.call(this, evt, target, dragEl) : this.options.direction;
            },
            _onTapStart: function _onTapStart(evt) {
                if (!evt.cancelable) return;
                var _this = this, el = this.el, options = this.options, preventOnFilter = options.preventOnFilter, type = evt.type, touch = evt.touches && evt.touches[0] || evt.pointerType && evt.pointerType === "touch" && evt, target = (touch || evt).target, originalTarget = evt.target.shadowRoot && (evt.path && evt.path[0] || evt.composedPath && evt.composedPath()[0]) || target, filter = options.filter;
                _saveInputCheckedState(el);
                if (dragEl) {
                    return;
                }
                if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) {
                    return;
                }
                if (originalTarget.isContentEditable) {
                    return;
                }
                if (!this.nativeDraggable && Safari && target && target.tagName.toUpperCase() === "SELECT") {
                    return;
                }
                target = closest(target, options.draggable, el, false);
                if (target && target.animated) {
                    return;
                }
                if (lastDownEl === target) {
                    return;
                }
                oldIndex = index(target);
                oldDraggableIndex = index(target, options.draggable);
                if (typeof filter === "function") {
                    if (filter.call(this, evt, target, this)) {
                        _dispatchEvent({
                            sortable: _this,
                            rootEl: originalTarget,
                            name: "filter",
                            targetEl: target,
                            toEl: el,
                            fromEl: el
                        });
                        pluginEvent("filter", _this, {
                            evt
                        });
                        preventOnFilter && evt.cancelable && evt.preventDefault();
                        return;
                    }
                } else if (filter) {
                    filter = filter.split(",").some((function(criteria) {
                        criteria = closest(originalTarget, criteria.trim(), el, false);
                        if (criteria) {
                            _dispatchEvent({
                                sortable: _this,
                                rootEl: criteria,
                                name: "filter",
                                targetEl: target,
                                fromEl: el,
                                toEl: el
                            });
                            pluginEvent("filter", _this, {
                                evt
                            });
                            return true;
                        }
                    }));
                    if (filter) {
                        preventOnFilter && evt.cancelable && evt.preventDefault();
                        return;
                    }
                }
                if (options.handle && !closest(originalTarget, options.handle, el, false)) {
                    return;
                }
                this._prepareDragStart(evt, touch, target);
            },
            _prepareDragStart: function _prepareDragStart(evt, touch, target) {
                var _this = this, el = _this.el, options = _this.options, ownerDocument = el.ownerDocument, dragStartFn;
                if (target && !dragEl && target.parentNode === el) {
                    var dragRect = getRect(target);
                    rootEl = el;
                    dragEl = target;
                    parentEl = dragEl.parentNode;
                    nextEl = dragEl.nextSibling;
                    lastDownEl = target;
                    activeGroup = options.group;
                    Sortable.dragged = dragEl;
                    tapEvt = {
                        target: dragEl,
                        clientX: (touch || evt).clientX,
                        clientY: (touch || evt).clientY
                    };
                    tapDistanceLeft = tapEvt.clientX - dragRect.left;
                    tapDistanceTop = tapEvt.clientY - dragRect.top;
                    this._lastX = (touch || evt).clientX;
                    this._lastY = (touch || evt).clientY;
                    dragEl.style["will-change"] = "all";
                    dragStartFn = function dragStartFn() {
                        pluginEvent("delayEnded", _this, {
                            evt
                        });
                        if (Sortable.eventCanceled) {
                            _this._onDrop();
                            return;
                        }
                        _this._disableDelayedDragEvents();
                        if (!FireFox && _this.nativeDraggable) {
                            dragEl.draggable = true;
                        }
                        _this._triggerDragStart(evt, touch);
                        _dispatchEvent({
                            sortable: _this,
                            name: "choose",
                            originalEvent: evt
                        });
                        toggleClass(dragEl, options.chosenClass, true);
                    };
                    options.ignore.split(",").forEach((function(criteria) {
                        find(dragEl, criteria.trim(), _disableDraggable);
                    }));
                    on(ownerDocument, "dragover", nearestEmptyInsertDetectEvent);
                    on(ownerDocument, "mousemove", nearestEmptyInsertDetectEvent);
                    on(ownerDocument, "touchmove", nearestEmptyInsertDetectEvent);
                    on(ownerDocument, "mouseup", _this._onDrop);
                    on(ownerDocument, "touchend", _this._onDrop);
                    on(ownerDocument, "touchcancel", _this._onDrop);
                    if (FireFox && this.nativeDraggable) {
                        this.options.touchStartThreshold = 4;
                        dragEl.draggable = true;
                    }
                    pluginEvent("delayStart", this, {
                        evt
                    });
                    if (options.delay && (!options.delayOnTouchOnly || touch) && (!this.nativeDraggable || !(Edge || IE11OrLess))) {
                        if (Sortable.eventCanceled) {
                            this._onDrop();
                            return;
                        }
                        on(ownerDocument, "mouseup", _this._disableDelayedDrag);
                        on(ownerDocument, "touchend", _this._disableDelayedDrag);
                        on(ownerDocument, "touchcancel", _this._disableDelayedDrag);
                        on(ownerDocument, "mousemove", _this._delayedDragTouchMoveHandler);
                        on(ownerDocument, "touchmove", _this._delayedDragTouchMoveHandler);
                        options.supportPointer && on(ownerDocument, "pointermove", _this._delayedDragTouchMoveHandler);
                        _this._dragStartTimer = setTimeout(dragStartFn, options.delay);
                    } else {
                        dragStartFn();
                    }
                }
            },
            _delayedDragTouchMoveHandler: function _delayedDragTouchMoveHandler(e) {
                var touch = e.touches ? e.touches[0] : e;
                if (Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) >= Math.floor(this.options.touchStartThreshold / (this.nativeDraggable && window.devicePixelRatio || 1))) {
                    this._disableDelayedDrag();
                }
            },
            _disableDelayedDrag: function _disableDelayedDrag() {
                dragEl && _disableDraggable(dragEl);
                clearTimeout(this._dragStartTimer);
                this._disableDelayedDragEvents();
            },
            _disableDelayedDragEvents: function _disableDelayedDragEvents() {
                var ownerDocument = this.el.ownerDocument;
                off(ownerDocument, "mouseup", this._disableDelayedDrag);
                off(ownerDocument, "touchend", this._disableDelayedDrag);
                off(ownerDocument, "touchcancel", this._disableDelayedDrag);
                off(ownerDocument, "mousemove", this._delayedDragTouchMoveHandler);
                off(ownerDocument, "touchmove", this._delayedDragTouchMoveHandler);
                off(ownerDocument, "pointermove", this._delayedDragTouchMoveHandler);
            },
            _triggerDragStart: function _triggerDragStart(evt, touch) {
                touch = touch || evt.pointerType == "touch" && evt;
                if (!this.nativeDraggable || touch) {
                    if (this.options.supportPointer) {
                        on(document, "pointermove", this._onTouchMove);
                    } else if (touch) {
                        on(document, "touchmove", this._onTouchMove);
                    } else {
                        on(document, "mousemove", this._onTouchMove);
                    }
                } else {
                    on(dragEl, "dragend", this);
                    on(rootEl, "dragstart", this._onDragStart);
                }
                try {
                    if (document.selection) {
                        _nextTick((function() {
                            document.selection.empty();
                        }));
                    } else {
                        window.getSelection().removeAllRanges();
                    }
                } catch (err) {}
            },
            _dragStarted: function _dragStarted(fallback, evt) {
                awaitingDragStarted = false;
                if (rootEl && dragEl) {
                    pluginEvent("dragStarted", this, {
                        evt
                    });
                    if (this.nativeDraggable) {
                        on(document, "dragover", _checkOutsideTargetEl);
                    }
                    var options = this.options;
                    !fallback && toggleClass(dragEl, options.dragClass, false);
                    toggleClass(dragEl, options.ghostClass, true);
                    Sortable.active = this;
                    fallback && this._appendGhost();
                    _dispatchEvent({
                        sortable: this,
                        name: "start",
                        originalEvent: evt
                    });
                } else {
                    this._nulling();
                }
            },
            _emulateDragOver: function _emulateDragOver() {
                if (touchEvt) {
                    this._lastX = touchEvt.clientX;
                    this._lastY = touchEvt.clientY;
                    _hideGhostForTarget();
                    var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
                    var parent = target;
                    while (target && target.shadowRoot) {
                        target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
                        if (target === parent) break;
                        parent = target;
                    }
                    dragEl.parentNode[expando]._isOutsideThisEl(target);
                    if (parent) {
                        do {
                            if (parent[expando]) {
                                var inserted = void 0;
                                inserted = parent[expando]._onDragOver({
                                    clientX: touchEvt.clientX,
                                    clientY: touchEvt.clientY,
                                    target,
                                    rootEl: parent
                                });
                                if (inserted && !this.options.dragoverBubble) {
                                    break;
                                }
                            }
                            target = parent;
                        } while (parent = parent.parentNode);
                    }
                    _unhideGhostForTarget();
                }
            },
            _onTouchMove: function _onTouchMove(evt) {
                if (tapEvt) {
                    var options = this.options, fallbackTolerance = options.fallbackTolerance, fallbackOffset = options.fallbackOffset, touch = evt.touches ? evt.touches[0] : evt, ghostMatrix = ghostEl && matrix(ghostEl, true), scaleX = ghostEl && ghostMatrix && ghostMatrix.a, scaleY = ghostEl && ghostMatrix && ghostMatrix.d, relativeScrollOffset = PositionGhostAbsolutely && ghostRelativeParent && getRelativeScrollOffset(ghostRelativeParent), dx = (touch.clientX - tapEvt.clientX + fallbackOffset.x) / (scaleX || 1) + (relativeScrollOffset ? relativeScrollOffset[0] - ghostRelativeParentInitialScroll[0] : 0) / (scaleX || 1), dy = (touch.clientY - tapEvt.clientY + fallbackOffset.y) / (scaleY || 1) + (relativeScrollOffset ? relativeScrollOffset[1] - ghostRelativeParentInitialScroll[1] : 0) / (scaleY || 1);
                    if (!Sortable.active && !awaitingDragStarted) {
                        if (fallbackTolerance && Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) < fallbackTolerance) {
                            return;
                        }
                        this._onDragStart(evt, true);
                    }
                    if (ghostEl) {
                        if (ghostMatrix) {
                            ghostMatrix.e += dx - (lastDx || 0);
                            ghostMatrix.f += dy - (lastDy || 0);
                        } else {
                            ghostMatrix = {
                                a: 1,
                                b: 0,
                                c: 0,
                                d: 1,
                                e: dx,
                                f: dy
                            };
                        }
                        var cssMatrix = "matrix(".concat(ghostMatrix.a, ",").concat(ghostMatrix.b, ",").concat(ghostMatrix.c, ",").concat(ghostMatrix.d, ",").concat(ghostMatrix.e, ",").concat(ghostMatrix.f, ")");
                        css(ghostEl, "webkitTransform", cssMatrix);
                        css(ghostEl, "mozTransform", cssMatrix);
                        css(ghostEl, "msTransform", cssMatrix);
                        css(ghostEl, "transform", cssMatrix);
                        lastDx = dx;
                        lastDy = dy;
                        touchEvt = touch;
                    }
                    evt.cancelable && evt.preventDefault();
                }
            },
            _appendGhost: function _appendGhost() {
                if (!ghostEl) {
                    var container = this.options.fallbackOnBody ? document.body : rootEl, rect = getRect(dragEl, true, PositionGhostAbsolutely, true, container), options = this.options;
                    if (PositionGhostAbsolutely) {
                        ghostRelativeParent = container;
                        while (css(ghostRelativeParent, "position") === "static" && css(ghostRelativeParent, "transform") === "none" && ghostRelativeParent !== document) {
                            ghostRelativeParent = ghostRelativeParent.parentNode;
                        }
                        if (ghostRelativeParent !== document.body && ghostRelativeParent !== document.documentElement) {
                            if (ghostRelativeParent === document) ghostRelativeParent = getWindowScrollingElement();
                            rect.top += ghostRelativeParent.scrollTop;
                            rect.left += ghostRelativeParent.scrollLeft;
                        } else {
                            ghostRelativeParent = getWindowScrollingElement();
                        }
                        ghostRelativeParentInitialScroll = getRelativeScrollOffset(ghostRelativeParent);
                    }
                    ghostEl = dragEl.cloneNode(true);
                    toggleClass(ghostEl, options.ghostClass, false);
                    toggleClass(ghostEl, options.fallbackClass, true);
                    toggleClass(ghostEl, options.dragClass, true);
                    css(ghostEl, "transition", "");
                    css(ghostEl, "transform", "");
                    css(ghostEl, "box-sizing", "border-box");
                    css(ghostEl, "margin", 0);
                    css(ghostEl, "top", rect.top);
                    css(ghostEl, "left", rect.left);
                    css(ghostEl, "width", rect.width);
                    css(ghostEl, "height", rect.height);
                    css(ghostEl, "opacity", "0.8");
                    css(ghostEl, "position", PositionGhostAbsolutely ? "absolute" : "fixed");
                    css(ghostEl, "zIndex", "100000");
                    css(ghostEl, "pointerEvents", "none");
                    Sortable.ghost = ghostEl;
                    container.appendChild(ghostEl);
                    css(ghostEl, "transform-origin", tapDistanceLeft / parseInt(ghostEl.style.width) * 100 + "% " + tapDistanceTop / parseInt(ghostEl.style.height) * 100 + "%");
                }
            },
            _onDragStart: function _onDragStart(evt, fallback) {
                var _this = this;
                var dataTransfer = evt.dataTransfer;
                var options = _this.options;
                pluginEvent("dragStart", this, {
                    evt
                });
                if (Sortable.eventCanceled) {
                    this._onDrop();
                    return;
                }
                pluginEvent("setupClone", this);
                if (!Sortable.eventCanceled) {
                    cloneEl = clone(dragEl);
                    cloneEl.removeAttribute("id");
                    cloneEl.draggable = false;
                    cloneEl.style["will-change"] = "";
                    this._hideClone();
                    toggleClass(cloneEl, this.options.chosenClass, false);
                    Sortable.clone = cloneEl;
                }
                _this.cloneId = _nextTick((function() {
                    pluginEvent("clone", _this);
                    if (Sortable.eventCanceled) return;
                    if (!_this.options.removeCloneOnHide) {
                        rootEl.insertBefore(cloneEl, dragEl);
                    }
                    _this._hideClone();
                    _dispatchEvent({
                        sortable: _this,
                        name: "clone"
                    });
                }));
                !fallback && toggleClass(dragEl, options.dragClass, true);
                if (fallback) {
                    ignoreNextClick = true;
                    _this._loopId = setInterval(_this._emulateDragOver, 50);
                } else {
                    off(document, "mouseup", _this._onDrop);
                    off(document, "touchend", _this._onDrop);
                    off(document, "touchcancel", _this._onDrop);
                    if (dataTransfer) {
                        dataTransfer.effectAllowed = "move";
                        options.setData && options.setData.call(_this, dataTransfer, dragEl);
                    }
                    on(document, "drop", _this);
                    css(dragEl, "transform", "translateZ(0)");
                }
                awaitingDragStarted = true;
                _this._dragStartId = _nextTick(_this._dragStarted.bind(_this, fallback, evt));
                on(document, "selectstart", _this);
                moved = true;
                if (Safari) {
                    css(document.body, "user-select", "none");
                }
            },
            _onDragOver: function _onDragOver(evt) {
                var el = this.el, target = evt.target, dragRect, targetRect, revert, options = this.options, group = options.group, activeSortable = Sortable.active, isOwner = activeGroup === group, canSort = options.sort, fromSortable = putSortable || activeSortable, vertical, _this = this, completedFired = false;
                if (_silent) return;
                function dragOverEvent(name, extra) {
                    pluginEvent(name, _this, _objectSpread2({
                        evt,
                        isOwner,
                        axis: vertical ? "vertical" : "horizontal",
                        revert,
                        dragRect,
                        targetRect,
                        canSort,
                        fromSortable,
                        target,
                        completed,
                        onMove: function onMove(target, after) {
                            return _onMove(rootEl, el, dragEl, dragRect, target, getRect(target), evt, after);
                        },
                        changed
                    }, extra));
                }
                function capture() {
                    dragOverEvent("dragOverAnimationCapture");
                    _this.captureAnimationState();
                    if (_this !== fromSortable) {
                        fromSortable.captureAnimationState();
                    }
                }
                function completed(insertion) {
                    dragOverEvent("dragOverCompleted", {
                        insertion
                    });
                    if (insertion) {
                        if (isOwner) {
                            activeSortable._hideClone();
                        } else {
                            activeSortable._showClone(_this);
                        }
                        if (_this !== fromSortable) {
                            toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : activeSortable.options.ghostClass, false);
                            toggleClass(dragEl, options.ghostClass, true);
                        }
                        if (putSortable !== _this && _this !== Sortable.active) {
                            putSortable = _this;
                        } else if (_this === Sortable.active && putSortable) {
                            putSortable = null;
                        }
                        if (fromSortable === _this) {
                            _this._ignoreWhileAnimating = target;
                        }
                        _this.animateAll((function() {
                            dragOverEvent("dragOverAnimationComplete");
                            _this._ignoreWhileAnimating = null;
                        }));
                        if (_this !== fromSortable) {
                            fromSortable.animateAll();
                            fromSortable._ignoreWhileAnimating = null;
                        }
                    }
                    if (target === dragEl && !dragEl.animated || target === el && !target.animated) {
                        lastTarget = null;
                    }
                    if (!options.dragoverBubble && !evt.rootEl && target !== document) {
                        dragEl.parentNode[expando]._isOutsideThisEl(evt.target);
                        !insertion && nearestEmptyInsertDetectEvent(evt);
                    }
                    !options.dragoverBubble && evt.stopPropagation && evt.stopPropagation();
                    return completedFired = true;
                }
                function changed() {
                    newIndex = index(dragEl);
                    newDraggableIndex = index(dragEl, options.draggable);
                    _dispatchEvent({
                        sortable: _this,
                        name: "change",
                        toEl: el,
                        newIndex,
                        newDraggableIndex,
                        originalEvent: evt
                    });
                }
                if (evt.preventDefault !== void 0) {
                    evt.cancelable && evt.preventDefault();
                }
                target = closest(target, options.draggable, el, true);
                dragOverEvent("dragOver");
                if (Sortable.eventCanceled) return completedFired;
                if (dragEl.contains(evt.target) || target.animated && target.animatingX && target.animatingY || _this._ignoreWhileAnimating === target) {
                    return completed(false);
                }
                ignoreNextClick = false;
                if (activeSortable && !options.disabled && (isOwner ? canSort || (revert = parentEl !== rootEl) : putSortable === this || (this.lastPutMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) && group.checkPut(this, activeSortable, dragEl, evt))) {
                    vertical = this._getDirection(evt, target) === "vertical";
                    dragRect = getRect(dragEl);
                    dragOverEvent("dragOverValid");
                    if (Sortable.eventCanceled) return completedFired;
                    if (revert) {
                        parentEl = rootEl;
                        capture();
                        this._hideClone();
                        dragOverEvent("revert");
                        if (!Sortable.eventCanceled) {
                            if (nextEl) {
                                rootEl.insertBefore(dragEl, nextEl);
                            } else {
                                rootEl.appendChild(dragEl);
                            }
                        }
                        return completed(true);
                    }
                    var elLastChild = lastChild(el, options.draggable);
                    if (!elLastChild || _ghostIsLast(evt, vertical, this) && !elLastChild.animated) {
                        if (elLastChild === dragEl) {
                            return completed(false);
                        }
                        if (elLastChild && el === evt.target) {
                            target = elLastChild;
                        }
                        if (target) {
                            targetRect = getRect(target);
                        }
                        if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, !!target) !== false) {
                            capture();
                            if (elLastChild && elLastChild.nextSibling) {
                                el.insertBefore(dragEl, elLastChild.nextSibling);
                            } else {
                                el.appendChild(dragEl);
                            }
                            parentEl = el;
                            changed();
                            return completed(true);
                        }
                    } else if (elLastChild && _ghostIsFirst(evt, vertical, this)) {
                        var firstChild = getChild(el, 0, options, true);
                        if (firstChild === dragEl) {
                            return completed(false);
                        }
                        target = firstChild;
                        targetRect = getRect(target);
                        if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, false) !== false) {
                            capture();
                            el.insertBefore(dragEl, firstChild);
                            parentEl = el;
                            changed();
                            return completed(true);
                        }
                    } else if (target.parentNode === el) {
                        targetRect = getRect(target);
                        var direction = 0, targetBeforeFirstSwap, differentLevel = dragEl.parentNode !== el, differentRowCol = !_dragElInRowColumn(dragEl.animated && dragEl.toRect || dragRect, target.animated && target.toRect || targetRect, vertical), side1 = vertical ? "top" : "left", scrolledPastTop = isScrolledPast(target, "top", "top") || isScrolledPast(dragEl, "top", "top"), scrollBefore = scrolledPastTop ? scrolledPastTop.scrollTop : void 0;
                        if (lastTarget !== target) {
                            targetBeforeFirstSwap = targetRect[side1];
                            pastFirstInvertThresh = false;
                            isCircumstantialInvert = !differentRowCol && options.invertSwap || differentLevel;
                        }
                        direction = _getSwapDirection(evt, target, targetRect, vertical, differentRowCol ? 1 : options.swapThreshold, options.invertedSwapThreshold == null ? options.swapThreshold : options.invertedSwapThreshold, isCircumstantialInvert, lastTarget === target);
                        var sibling;
                        if (direction !== 0) {
                            var dragIndex = index(dragEl);
                            do {
                                dragIndex -= direction;
                                sibling = parentEl.children[dragIndex];
                            } while (sibling && (css(sibling, "display") === "none" || sibling === ghostEl));
                        }
                        if (direction === 0 || sibling === target) {
                            return completed(false);
                        }
                        lastTarget = target;
                        lastDirection = direction;
                        var nextSibling = target.nextElementSibling, after = false;
                        after = direction === 1;
                        var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after);
                        if (moveVector !== false) {
                            if (moveVector === 1 || moveVector === -1) {
                                after = moveVector === 1;
                            }
                            _silent = true;
                            setTimeout(_unsilent, 30);
                            capture();
                            if (after && !nextSibling) {
                                el.appendChild(dragEl);
                            } else {
                                target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
                            }
                            if (scrolledPastTop) {
                                scrollBy(scrolledPastTop, 0, scrollBefore - scrolledPastTop.scrollTop);
                            }
                            parentEl = dragEl.parentNode;
                            if (targetBeforeFirstSwap !== undefined && !isCircumstantialInvert) {
                                targetMoveDistance = Math.abs(targetBeforeFirstSwap - getRect(target)[side1]);
                            }
                            changed();
                            return completed(true);
                        }
                    }
                    if (el.contains(dragEl)) {
                        return completed(false);
                    }
                }
                return false;
            },
            _ignoreWhileAnimating: null,
            _offMoveEvents: function _offMoveEvents() {
                off(document, "mousemove", this._onTouchMove);
                off(document, "touchmove", this._onTouchMove);
                off(document, "pointermove", this._onTouchMove);
                off(document, "dragover", nearestEmptyInsertDetectEvent);
                off(document, "mousemove", nearestEmptyInsertDetectEvent);
                off(document, "touchmove", nearestEmptyInsertDetectEvent);
            },
            _offUpEvents: function _offUpEvents() {
                var ownerDocument = this.el.ownerDocument;
                off(ownerDocument, "mouseup", this._onDrop);
                off(ownerDocument, "touchend", this._onDrop);
                off(ownerDocument, "pointerup", this._onDrop);
                off(ownerDocument, "touchcancel", this._onDrop);
                off(document, "selectstart", this);
            },
            _onDrop: function _onDrop(evt) {
                var el = this.el, options = this.options;
                newIndex = index(dragEl);
                newDraggableIndex = index(dragEl, options.draggable);
                pluginEvent("drop", this, {
                    evt
                });
                parentEl = dragEl && dragEl.parentNode;
                newIndex = index(dragEl);
                newDraggableIndex = index(dragEl, options.draggable);
                if (Sortable.eventCanceled) {
                    this._nulling();
                    return;
                }
                awaitingDragStarted = false;
                isCircumstantialInvert = false;
                pastFirstInvertThresh = false;
                clearInterval(this._loopId);
                clearTimeout(this._dragStartTimer);
                _cancelNextTick(this.cloneId);
                _cancelNextTick(this._dragStartId);
                if (this.nativeDraggable) {
                    off(document, "drop", this);
                    off(el, "dragstart", this._onDragStart);
                }
                this._offMoveEvents();
                this._offUpEvents();
                if (Safari) {
                    css(document.body, "user-select", "");
                }
                css(dragEl, "transform", "");
                if (evt) {
                    if (moved) {
                        evt.cancelable && evt.preventDefault();
                        !options.dropBubble && evt.stopPropagation();
                    }
                    ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl);
                    if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== "clone") {
                        cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl);
                    }
                    if (dragEl) {
                        if (this.nativeDraggable) {
                            off(dragEl, "dragend", this);
                        }
                        _disableDraggable(dragEl);
                        dragEl.style["will-change"] = "";
                        if (moved && !awaitingDragStarted) {
                            toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : this.options.ghostClass, false);
                        }
                        toggleClass(dragEl, this.options.chosenClass, false);
                        _dispatchEvent({
                            sortable: this,
                            name: "unchoose",
                            toEl: parentEl,
                            newIndex: null,
                            newDraggableIndex: null,
                            originalEvent: evt
                        });
                        if (rootEl !== parentEl) {
                            if (newIndex >= 0) {
                                _dispatchEvent({
                                    rootEl: parentEl,
                                    name: "add",
                                    toEl: parentEl,
                                    fromEl: rootEl,
                                    originalEvent: evt
                                });
                                _dispatchEvent({
                                    sortable: this,
                                    name: "remove",
                                    toEl: parentEl,
                                    originalEvent: evt
                                });
                                _dispatchEvent({
                                    rootEl: parentEl,
                                    name: "sort",
                                    toEl: parentEl,
                                    fromEl: rootEl,
                                    originalEvent: evt
                                });
                                _dispatchEvent({
                                    sortable: this,
                                    name: "sort",
                                    toEl: parentEl,
                                    originalEvent: evt
                                });
                            }
                            putSortable && putSortable.save();
                        } else {
                            if (newIndex !== oldIndex) {
                                if (newIndex >= 0) {
                                    _dispatchEvent({
                                        sortable: this,
                                        name: "update",
                                        toEl: parentEl,
                                        originalEvent: evt
                                    });
                                    _dispatchEvent({
                                        sortable: this,
                                        name: "sort",
                                        toEl: parentEl,
                                        originalEvent: evt
                                    });
                                }
                            }
                        }
                        if (Sortable.active) {
                            if (newIndex == null || newIndex === -1) {
                                newIndex = oldIndex;
                                newDraggableIndex = oldDraggableIndex;
                            }
                            _dispatchEvent({
                                sortable: this,
                                name: "end",
                                toEl: parentEl,
                                originalEvent: evt
                            });
                            this.save();
                        }
                    }
                }
                this._nulling();
            },
            _nulling: function _nulling() {
                pluginEvent("nulling", this);
                rootEl = dragEl = parentEl = ghostEl = nextEl = cloneEl = lastDownEl = cloneHidden = tapEvt = touchEvt = moved = newIndex = newDraggableIndex = oldIndex = oldDraggableIndex = lastTarget = lastDirection = putSortable = activeGroup = Sortable.dragged = Sortable.ghost = Sortable.clone = Sortable.active = null;
                savedInputChecked.forEach((function(el) {
                    el.checked = true;
                }));
                savedInputChecked.length = lastDx = lastDy = 0;
            },
            handleEvent: function handleEvent(evt) {
                switch (evt.type) {
                  case "drop":
                  case "dragend":
                    this._onDrop(evt);
                    break;

                  case "dragenter":
                  case "dragover":
                    if (dragEl) {
                        this._onDragOver(evt);
                        _globalDragOver(evt);
                    }
                    break;

                  case "selectstart":
                    evt.preventDefault();
                    break;
                }
            },
            toArray: function toArray() {
                var order = [], el, children = this.el.children, i = 0, n = children.length, options = this.options;
                for (;i < n; i++) {
                    el = children[i];
                    if (closest(el, options.draggable, this.el, false)) {
                        order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
                    }
                }
                return order;
            },
            sort: function sort(order, useAnimation) {
                var items = {}, rootEl = this.el;
                this.toArray().forEach((function(id, i) {
                    var el = rootEl.children[i];
                    if (closest(el, this.options.draggable, rootEl, false)) {
                        items[id] = el;
                    }
                }), this);
                useAnimation && this.captureAnimationState();
                order.forEach((function(id) {
                    if (items[id]) {
                        rootEl.removeChild(items[id]);
                        rootEl.appendChild(items[id]);
                    }
                }));
                useAnimation && this.animateAll();
            },
            save: function save() {
                var store = this.options.store;
                store && store.set && store.set(this);
            },
            closest: function closest$1(el, selector) {
                return closest(el, selector || this.options.draggable, this.el, false);
            },
            option: function option(name, value) {
                var options = this.options;
                if (value === void 0) {
                    return options[name];
                } else {
                    var modifiedValue = PluginManager.modifyOption(this, name, value);
                    if (typeof modifiedValue !== "undefined") {
                        options[name] = modifiedValue;
                    } else {
                        options[name] = value;
                    }
                    if (name === "group") {
                        _prepareGroup(options);
                    }
                }
            },
            destroy: function destroy() {
                pluginEvent("destroy", this);
                var el = this.el;
                el[expando] = null;
                off(el, "mousedown", this._onTapStart);
                off(el, "touchstart", this._onTapStart);
                off(el, "pointerdown", this._onTapStart);
                if (this.nativeDraggable) {
                    off(el, "dragover", this);
                    off(el, "dragenter", this);
                }
                Array.prototype.forEach.call(el.querySelectorAll("[draggable]"), (function(el) {
                    el.removeAttribute("draggable");
                }));
                this._onDrop();
                this._disableDelayedDragEvents();
                sortables.splice(sortables.indexOf(this.el), 1);
                this.el = el = null;
            },
            _hideClone: function _hideClone() {
                if (!cloneHidden) {
                    pluginEvent("hideClone", this);
                    if (Sortable.eventCanceled) return;
                    css(cloneEl, "display", "none");
                    if (this.options.removeCloneOnHide && cloneEl.parentNode) {
                        cloneEl.parentNode.removeChild(cloneEl);
                    }
                    cloneHidden = true;
                }
            },
            _showClone: function _showClone(putSortable) {
                if (putSortable.lastPutMode !== "clone") {
                    this._hideClone();
                    return;
                }
                if (cloneHidden) {
                    pluginEvent("showClone", this);
                    if (Sortable.eventCanceled) return;
                    if (dragEl.parentNode == rootEl && !this.options.group.revertClone) {
                        rootEl.insertBefore(cloneEl, dragEl);
                    } else if (nextEl) {
                        rootEl.insertBefore(cloneEl, nextEl);
                    } else {
                        rootEl.appendChild(cloneEl);
                    }
                    if (this.options.group.revertClone) {
                        this.animate(dragEl, cloneEl);
                    }
                    css(cloneEl, "display", "");
                    cloneHidden = false;
                }
            }
        };
        function _globalDragOver(evt) {
            if (evt.dataTransfer) {
                evt.dataTransfer.dropEffect = "move";
            }
            evt.cancelable && evt.preventDefault();
        }
        function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvent, willInsertAfter) {
            var evt, sortable = fromEl[expando], onMoveFn = sortable.options.onMove, retVal;
            if (window.CustomEvent && !IE11OrLess && !Edge) {
                evt = new CustomEvent("move", {
                    bubbles: true,
                    cancelable: true
                });
            } else {
                evt = document.createEvent("Event");
                evt.initEvent("move", true, true);
            }
            evt.to = toEl;
            evt.from = fromEl;
            evt.dragged = dragEl;
            evt.draggedRect = dragRect;
            evt.related = targetEl || toEl;
            evt.relatedRect = targetRect || getRect(toEl);
            evt.willInsertAfter = willInsertAfter;
            evt.originalEvent = originalEvent;
            fromEl.dispatchEvent(evt);
            if (onMoveFn) {
                retVal = onMoveFn.call(sortable, evt, originalEvent);
            }
            return retVal;
        }
        function _disableDraggable(el) {
            el.draggable = false;
        }
        function _unsilent() {
            _silent = false;
        }
        function _ghostIsFirst(evt, vertical, sortable) {
            var rect = getRect(getChild(sortable.el, 0, sortable.options, true));
            var spacer = 10;
            return vertical ? evt.clientX < rect.left - spacer || evt.clientY < rect.top && evt.clientX < rect.right : evt.clientY < rect.top - spacer || evt.clientY < rect.bottom && evt.clientX < rect.left;
        }
        function _ghostIsLast(evt, vertical, sortable) {
            var rect = getRect(lastChild(sortable.el, sortable.options.draggable));
            var spacer = 10;
            return vertical ? evt.clientX > rect.right + spacer || evt.clientX <= rect.right && evt.clientY > rect.bottom && evt.clientX >= rect.left : evt.clientX > rect.right && evt.clientY > rect.top || evt.clientX <= rect.right && evt.clientY > rect.bottom + spacer;
        }
        function _getSwapDirection(evt, target, targetRect, vertical, swapThreshold, invertedSwapThreshold, invertSwap, isLastTarget) {
            var mouseOnAxis = vertical ? evt.clientY : evt.clientX, targetLength = vertical ? targetRect.height : targetRect.width, targetS1 = vertical ? targetRect.top : targetRect.left, targetS2 = vertical ? targetRect.bottom : targetRect.right, invert = false;
            if (!invertSwap) {
                if (isLastTarget && targetMoveDistance < targetLength * swapThreshold) {
                    if (!pastFirstInvertThresh && (lastDirection === 1 ? mouseOnAxis > targetS1 + targetLength * invertedSwapThreshold / 2 : mouseOnAxis < targetS2 - targetLength * invertedSwapThreshold / 2)) {
                        pastFirstInvertThresh = true;
                    }
                    if (!pastFirstInvertThresh) {
                        if (lastDirection === 1 ? mouseOnAxis < targetS1 + targetMoveDistance : mouseOnAxis > targetS2 - targetMoveDistance) {
                            return -lastDirection;
                        }
                    } else {
                        invert = true;
                    }
                } else {
                    if (mouseOnAxis > targetS1 + targetLength * (1 - swapThreshold) / 2 && mouseOnAxis < targetS2 - targetLength * (1 - swapThreshold) / 2) {
                        return _getInsertDirection(target);
                    }
                }
            }
            invert = invert || invertSwap;
            if (invert) {
                if (mouseOnAxis < targetS1 + targetLength * invertedSwapThreshold / 2 || mouseOnAxis > targetS2 - targetLength * invertedSwapThreshold / 2) {
                    return mouseOnAxis > targetS1 + targetLength / 2 ? 1 : -1;
                }
            }
            return 0;
        }
        function _getInsertDirection(target) {
            if (index(dragEl) < index(target)) {
                return 1;
            } else {
                return -1;
            }
        }
        function _generateId(el) {
            var str = el.tagName + el.className + el.src + el.href + el.textContent, i = str.length, sum = 0;
            while (i--) {
                sum += str.charCodeAt(i);
            }
            return sum.toString(36);
        }
        function _saveInputCheckedState(root) {
            savedInputChecked.length = 0;
            var inputs = root.getElementsByTagName("input");
            var idx = inputs.length;
            while (idx--) {
                var el = inputs[idx];
                el.checked && savedInputChecked.push(el);
            }
        }
        function _nextTick(fn) {
            return setTimeout(fn, 0);
        }
        function _cancelNextTick(id) {
            return clearTimeout(id);
        }
        if (documentExists) {
            on(document, "touchmove", (function(evt) {
                if ((Sortable.active || awaitingDragStarted) && evt.cancelable) {
                    evt.preventDefault();
                }
            }));
        }
        Sortable.utils = {
            on,
            off,
            css,
            find,
            is: function is(el, selector) {
                return !!closest(el, selector, el, false);
            },
            extend,
            throttle,
            closest,
            toggleClass,
            clone,
            index,
            nextTick: _nextTick,
            cancelNextTick: _cancelNextTick,
            detectDirection: _detectDirection,
            getChild
        };
        Sortable.get = function(element) {
            return element[expando];
        };
        Sortable.mount = function() {
            for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
                plugins[_key] = arguments[_key];
            }
            if (plugins[0].constructor === Array) plugins = plugins[0];
            plugins.forEach((function(plugin) {
                if (!plugin.prototype || !plugin.prototype.constructor) {
                    throw "Sortable: Mounted plugin must be a constructor function, not ".concat({}.toString.call(plugin));
                }
                if (plugin.utils) Sortable.utils = _objectSpread2(_objectSpread2({}, Sortable.utils), plugin.utils);
                PluginManager.mount(plugin);
            }));
        };
        Sortable.create = function(el, options) {
            return new Sortable(el, options);
        };
        Sortable.version = version;
        var autoScrolls = [], scrollEl, scrollRootEl, scrolling = false, lastAutoScrollX, lastAutoScrollY, touchEvt$1, pointerElemChangedInterval;
        function AutoScrollPlugin() {
            function AutoScroll() {
                this.defaults = {
                    scroll: true,
                    forceAutoScrollFallback: false,
                    scrollSensitivity: 30,
                    scrollSpeed: 10,
                    bubbleScroll: true
                };
                for (var fn in this) {
                    if (fn.charAt(0) === "_" && typeof this[fn] === "function") {
                        this[fn] = this[fn].bind(this);
                    }
                }
            }
            AutoScroll.prototype = {
                dragStarted: function dragStarted(_ref) {
                    var originalEvent = _ref.originalEvent;
                    if (this.sortable.nativeDraggable) {
                        on(document, "dragover", this._handleAutoScroll);
                    } else {
                        if (this.options.supportPointer) {
                            on(document, "pointermove", this._handleFallbackAutoScroll);
                        } else if (originalEvent.touches) {
                            on(document, "touchmove", this._handleFallbackAutoScroll);
                        } else {
                            on(document, "mousemove", this._handleFallbackAutoScroll);
                        }
                    }
                },
                dragOverCompleted: function dragOverCompleted(_ref2) {
                    var originalEvent = _ref2.originalEvent;
                    if (!this.options.dragOverBubble && !originalEvent.rootEl) {
                        this._handleAutoScroll(originalEvent);
                    }
                },
                drop: function drop() {
                    if (this.sortable.nativeDraggable) {
                        off(document, "dragover", this._handleAutoScroll);
                    } else {
                        off(document, "pointermove", this._handleFallbackAutoScroll);
                        off(document, "touchmove", this._handleFallbackAutoScroll);
                        off(document, "mousemove", this._handleFallbackAutoScroll);
                    }
                    clearPointerElemChangedInterval();
                    clearAutoScrolls();
                    cancelThrottle();
                },
                nulling: function nulling() {
                    touchEvt$1 = scrollRootEl = scrollEl = scrolling = pointerElemChangedInterval = lastAutoScrollX = lastAutoScrollY = null;
                    autoScrolls.length = 0;
                },
                _handleFallbackAutoScroll: function _handleFallbackAutoScroll(evt) {
                    this._handleAutoScroll(evt, true);
                },
                _handleAutoScroll: function _handleAutoScroll(evt, fallback) {
                    var _this = this;
                    var x = (evt.touches ? evt.touches[0] : evt).clientX, y = (evt.touches ? evt.touches[0] : evt).clientY, elem = document.elementFromPoint(x, y);
                    touchEvt$1 = evt;
                    if (fallback || this.options.forceAutoScrollFallback || Edge || IE11OrLess || Safari) {
                        autoScroll(evt, this.options, elem, fallback);
                        var ogElemScroller = getParentAutoScrollElement(elem, true);
                        if (scrolling && (!pointerElemChangedInterval || x !== lastAutoScrollX || y !== lastAutoScrollY)) {
                            pointerElemChangedInterval && clearPointerElemChangedInterval();
                            pointerElemChangedInterval = setInterval((function() {
                                var newElem = getParentAutoScrollElement(document.elementFromPoint(x, y), true);
                                if (newElem !== ogElemScroller) {
                                    ogElemScroller = newElem;
                                    clearAutoScrolls();
                                }
                                autoScroll(evt, _this.options, newElem, fallback);
                            }), 10);
                            lastAutoScrollX = x;
                            lastAutoScrollY = y;
                        }
                    } else {
                        if (!this.options.bubbleScroll || getParentAutoScrollElement(elem, true) === getWindowScrollingElement()) {
                            clearAutoScrolls();
                            return;
                        }
                        autoScroll(evt, this.options, getParentAutoScrollElement(elem, false), false);
                    }
                }
            };
            return _extends(AutoScroll, {
                pluginName: "scroll",
                initializeByDefault: true
            });
        }
        function clearAutoScrolls() {
            autoScrolls.forEach((function(autoScroll) {
                clearInterval(autoScroll.pid);
            }));
            autoScrolls = [];
        }
        function clearPointerElemChangedInterval() {
            clearInterval(pointerElemChangedInterval);
        }
        var autoScroll = throttle((function(evt, options, rootEl, isFallback) {
            if (!options.scroll) return;
            var x = (evt.touches ? evt.touches[0] : evt).clientX, y = (evt.touches ? evt.touches[0] : evt).clientY, sens = options.scrollSensitivity, speed = options.scrollSpeed, winScroller = getWindowScrollingElement();
            var scrollThisInstance = false, scrollCustomFn;
            if (scrollRootEl !== rootEl) {
                scrollRootEl = rootEl;
                clearAutoScrolls();
                scrollEl = options.scroll;
                scrollCustomFn = options.scrollFn;
                if (scrollEl === true) {
                    scrollEl = getParentAutoScrollElement(rootEl, true);
                }
            }
            var layersOut = 0;
            var currentParent = scrollEl;
            do {
                var el = currentParent, rect = getRect(el), top = rect.top, bottom = rect.bottom, left = rect.left, right = rect.right, width = rect.width, height = rect.height, canScrollX = void 0, canScrollY = void 0, scrollWidth = el.scrollWidth, scrollHeight = el.scrollHeight, elCSS = css(el), scrollPosX = el.scrollLeft, scrollPosY = el.scrollTop;
                if (el === winScroller) {
                    canScrollX = width < scrollWidth && (elCSS.overflowX === "auto" || elCSS.overflowX === "scroll" || elCSS.overflowX === "visible");
                    canScrollY = height < scrollHeight && (elCSS.overflowY === "auto" || elCSS.overflowY === "scroll" || elCSS.overflowY === "visible");
                } else {
                    canScrollX = width < scrollWidth && (elCSS.overflowX === "auto" || elCSS.overflowX === "scroll");
                    canScrollY = height < scrollHeight && (elCSS.overflowY === "auto" || elCSS.overflowY === "scroll");
                }
                var vx = canScrollX && (Math.abs(right - x) <= sens && scrollPosX + width < scrollWidth) - (Math.abs(left - x) <= sens && !!scrollPosX);
                var vy = canScrollY && (Math.abs(bottom - y) <= sens && scrollPosY + height < scrollHeight) - (Math.abs(top - y) <= sens && !!scrollPosY);
                if (!autoScrolls[layersOut]) {
                    for (var i = 0; i <= layersOut; i++) {
                        if (!autoScrolls[i]) {
                            autoScrolls[i] = {};
                        }
                    }
                }
                if (autoScrolls[layersOut].vx != vx || autoScrolls[layersOut].vy != vy || autoScrolls[layersOut].el !== el) {
                    autoScrolls[layersOut].el = el;
                    autoScrolls[layersOut].vx = vx;
                    autoScrolls[layersOut].vy = vy;
                    clearInterval(autoScrolls[layersOut].pid);
                    if (vx != 0 || vy != 0) {
                        scrollThisInstance = true;
                        autoScrolls[layersOut].pid = setInterval(function() {
                            if (isFallback && this.layer === 0) {
                                Sortable.active._onTouchMove(touchEvt$1);
                            }
                            var scrollOffsetY = autoScrolls[this.layer].vy ? autoScrolls[this.layer].vy * speed : 0;
                            var scrollOffsetX = autoScrolls[this.layer].vx ? autoScrolls[this.layer].vx * speed : 0;
                            if (typeof scrollCustomFn === "function") {
                                if (scrollCustomFn.call(Sortable.dragged.parentNode[expando], scrollOffsetX, scrollOffsetY, evt, touchEvt$1, autoScrolls[this.layer].el) !== "continue") {
                                    return;
                                }
                            }
                            scrollBy(autoScrolls[this.layer].el, scrollOffsetX, scrollOffsetY);
                        }.bind({
                            layer: layersOut
                        }), 24);
                    }
                }
                layersOut++;
            } while (options.bubbleScroll && currentParent !== winScroller && (currentParent = getParentAutoScrollElement(currentParent, false)));
            scrolling = scrollThisInstance;
        }), 30);
        var drop = function drop(_ref) {
            var originalEvent = _ref.originalEvent, putSortable = _ref.putSortable, dragEl = _ref.dragEl, activeSortable = _ref.activeSortable, dispatchSortableEvent = _ref.dispatchSortableEvent, hideGhostForTarget = _ref.hideGhostForTarget, unhideGhostForTarget = _ref.unhideGhostForTarget;
            if (!originalEvent) return;
            var toSortable = putSortable || activeSortable;
            hideGhostForTarget();
            var touch = originalEvent.changedTouches && originalEvent.changedTouches.length ? originalEvent.changedTouches[0] : originalEvent;
            var target = document.elementFromPoint(touch.clientX, touch.clientY);
            unhideGhostForTarget();
            if (toSortable && !toSortable.el.contains(target)) {
                dispatchSortableEvent("spill");
                this.onSpill({
                    dragEl,
                    putSortable
                });
            }
        };
        function Revert() {}
        Revert.prototype = {
            startIndex: null,
            dragStart: function dragStart(_ref2) {
                var oldDraggableIndex = _ref2.oldDraggableIndex;
                this.startIndex = oldDraggableIndex;
            },
            onSpill: function onSpill(_ref3) {
                var dragEl = _ref3.dragEl, putSortable = _ref3.putSortable;
                this.sortable.captureAnimationState();
                if (putSortable) {
                    putSortable.captureAnimationState();
                }
                var nextSibling = getChild(this.sortable.el, this.startIndex, this.options);
                if (nextSibling) {
                    this.sortable.el.insertBefore(dragEl, nextSibling);
                } else {
                    this.sortable.el.appendChild(dragEl);
                }
                this.sortable.animateAll();
                if (putSortable) {
                    putSortable.animateAll();
                }
            },
            drop
        };
        _extends(Revert, {
            pluginName: "revertOnSpill"
        });
        function Remove() {}
        Remove.prototype = {
            onSpill: function onSpill(_ref4) {
                var dragEl = _ref4.dragEl, putSortable = _ref4.putSortable;
                var parentSortable = putSortable || this.sortable;
                parentSortable.captureAnimationState();
                dragEl.parentNode && dragEl.parentNode.removeChild(dragEl);
                parentSortable.animateAll();
            },
            drop
        };
        _extends(Remove, {
            pluginName: "removeOnSpill"
        });
        var lastSwapEl;
        function SwapPlugin() {
            function Swap() {
                this.defaults = {
                    swapClass: "sortable-swap-highlight"
                };
            }
            Swap.prototype = {
                dragStart: function dragStart(_ref) {
                    var dragEl = _ref.dragEl;
                    lastSwapEl = dragEl;
                },
                dragOverValid: function dragOverValid(_ref2) {
                    var completed = _ref2.completed, target = _ref2.target, onMove = _ref2.onMove, activeSortable = _ref2.activeSortable, changed = _ref2.changed, cancel = _ref2.cancel;
                    if (!activeSortable.options.swap) return;
                    var el = this.sortable.el, options = this.options;
                    if (target && target !== el) {
                        var prevSwapEl = lastSwapEl;
                        if (onMove(target) !== false) {
                            toggleClass(target, options.swapClass, true);
                            lastSwapEl = target;
                        } else {
                            lastSwapEl = null;
                        }
                        if (prevSwapEl && prevSwapEl !== lastSwapEl) {
                            toggleClass(prevSwapEl, options.swapClass, false);
                        }
                    }
                    changed();
                    completed(true);
                    cancel();
                },
                drop: function drop(_ref3) {
                    var activeSortable = _ref3.activeSortable, putSortable = _ref3.putSortable, dragEl = _ref3.dragEl;
                    var toSortable = putSortable || this.sortable;
                    var options = this.options;
                    lastSwapEl && toggleClass(lastSwapEl, options.swapClass, false);
                    if (lastSwapEl && (options.swap || putSortable && putSortable.options.swap)) {
                        if (dragEl !== lastSwapEl) {
                            toSortable.captureAnimationState();
                            if (toSortable !== activeSortable) activeSortable.captureAnimationState();
                            swapNodes(dragEl, lastSwapEl);
                            toSortable.animateAll();
                            if (toSortable !== activeSortable) activeSortable.animateAll();
                        }
                    }
                },
                nulling: function nulling() {
                    lastSwapEl = null;
                }
            };
            return _extends(Swap, {
                pluginName: "swap",
                eventProperties: function eventProperties() {
                    return {
                        swapItem: lastSwapEl
                    };
                }
            });
        }
        function swapNodes(n1, n2) {
            var p1 = n1.parentNode, p2 = n2.parentNode, i1, i2;
            if (!p1 || !p2 || p1.isEqualNode(n2) || p2.isEqualNode(n1)) return;
            i1 = index(n1);
            i2 = index(n2);
            if (p1.isEqualNode(p2) && i1 < i2) {
                i2++;
            }
            p1.insertBefore(n2, p1.children[i1]);
            p2.insertBefore(n1, p2.children[i2]);
        }
        var multiDragElements = [], multiDragClones = [], lastMultiDragSelect, multiDragSortable, initialFolding = false, folding = false, dragStarted = false, dragEl$1, clonesFromRect, clonesHidden;
        function MultiDragPlugin() {
            function MultiDrag(sortable) {
                for (var fn in this) {
                    if (fn.charAt(0) === "_" && typeof this[fn] === "function") {
                        this[fn] = this[fn].bind(this);
                    }
                }
                if (!sortable.options.avoidImplicitDeselect) {
                    if (sortable.options.supportPointer) {
                        on(document, "pointerup", this._deselectMultiDrag);
                    } else {
                        on(document, "mouseup", this._deselectMultiDrag);
                        on(document, "touchend", this._deselectMultiDrag);
                    }
                }
                on(document, "keydown", this._checkKeyDown);
                on(document, "keyup", this._checkKeyUp);
                this.defaults = {
                    selectedClass: "sortable-selected",
                    multiDragKey: null,
                    avoidImplicitDeselect: false,
                    setData: function setData(dataTransfer, dragEl) {
                        var data = "";
                        if (multiDragElements.length && multiDragSortable === sortable) {
                            multiDragElements.forEach((function(multiDragElement, i) {
                                data += (!i ? "" : ", ") + multiDragElement.textContent;
                            }));
                        } else {
                            data = dragEl.textContent;
                        }
                        dataTransfer.setData("Text", data);
                    }
                };
            }
            MultiDrag.prototype = {
                multiDragKeyDown: false,
                isMultiDrag: false,
                delayStartGlobal: function delayStartGlobal(_ref) {
                    var dragged = _ref.dragEl;
                    dragEl$1 = dragged;
                },
                delayEnded: function delayEnded() {
                    this.isMultiDrag = ~multiDragElements.indexOf(dragEl$1);
                },
                setupClone: function setupClone(_ref2) {
                    var sortable = _ref2.sortable, cancel = _ref2.cancel;
                    if (!this.isMultiDrag) return;
                    for (var i = 0; i < multiDragElements.length; i++) {
                        multiDragClones.push(clone(multiDragElements[i]));
                        multiDragClones[i].sortableIndex = multiDragElements[i].sortableIndex;
                        multiDragClones[i].draggable = false;
                        multiDragClones[i].style["will-change"] = "";
                        toggleClass(multiDragClones[i], this.options.selectedClass, false);
                        multiDragElements[i] === dragEl$1 && toggleClass(multiDragClones[i], this.options.chosenClass, false);
                    }
                    sortable._hideClone();
                    cancel();
                },
                clone: function clone(_ref3) {
                    var sortable = _ref3.sortable, rootEl = _ref3.rootEl, dispatchSortableEvent = _ref3.dispatchSortableEvent, cancel = _ref3.cancel;
                    if (!this.isMultiDrag) return;
                    if (!this.options.removeCloneOnHide) {
                        if (multiDragElements.length && multiDragSortable === sortable) {
                            insertMultiDragClones(true, rootEl);
                            dispatchSortableEvent("clone");
                            cancel();
                        }
                    }
                },
                showClone: function showClone(_ref4) {
                    var cloneNowShown = _ref4.cloneNowShown, rootEl = _ref4.rootEl, cancel = _ref4.cancel;
                    if (!this.isMultiDrag) return;
                    insertMultiDragClones(false, rootEl);
                    multiDragClones.forEach((function(clone) {
                        css(clone, "display", "");
                    }));
                    cloneNowShown();
                    clonesHidden = false;
                    cancel();
                },
                hideClone: function hideClone(_ref5) {
                    var _this = this;
                    var sortable = _ref5.sortable, cloneNowHidden = _ref5.cloneNowHidden, cancel = _ref5.cancel;
                    if (!this.isMultiDrag) return;
                    multiDragClones.forEach((function(clone) {
                        css(clone, "display", "none");
                        if (_this.options.removeCloneOnHide && clone.parentNode) {
                            clone.parentNode.removeChild(clone);
                        }
                    }));
                    cloneNowHidden();
                    clonesHidden = true;
                    cancel();
                },
                dragStartGlobal: function dragStartGlobal(_ref6) {
                    var sortable = _ref6.sortable;
                    if (!this.isMultiDrag && multiDragSortable) {
                        multiDragSortable.multiDrag._deselectMultiDrag();
                    }
                    multiDragElements.forEach((function(multiDragElement) {
                        multiDragElement.sortableIndex = index(multiDragElement);
                    }));
                    multiDragElements = multiDragElements.sort((function(a, b) {
                        return a.sortableIndex - b.sortableIndex;
                    }));
                    dragStarted = true;
                },
                dragStarted: function dragStarted(_ref7) {
                    var _this2 = this;
                    var sortable = _ref7.sortable;
                    if (!this.isMultiDrag) return;
                    if (this.options.sort) {
                        sortable.captureAnimationState();
                        if (this.options.animation) {
                            multiDragElements.forEach((function(multiDragElement) {
                                if (multiDragElement === dragEl$1) return;
                                css(multiDragElement, "position", "absolute");
                            }));
                            var dragRect = getRect(dragEl$1, false, true, true);
                            multiDragElements.forEach((function(multiDragElement) {
                                if (multiDragElement === dragEl$1) return;
                                setRect(multiDragElement, dragRect);
                            }));
                            folding = true;
                            initialFolding = true;
                        }
                    }
                    sortable.animateAll((function() {
                        folding = false;
                        initialFolding = false;
                        if (_this2.options.animation) {
                            multiDragElements.forEach((function(multiDragElement) {
                                unsetRect(multiDragElement);
                            }));
                        }
                        if (_this2.options.sort) {
                            removeMultiDragElements();
                        }
                    }));
                },
                dragOver: function dragOver(_ref8) {
                    var target = _ref8.target, completed = _ref8.completed, cancel = _ref8.cancel;
                    if (folding && ~multiDragElements.indexOf(target)) {
                        completed(false);
                        cancel();
                    }
                },
                revert: function revert(_ref9) {
                    var fromSortable = _ref9.fromSortable, rootEl = _ref9.rootEl, sortable = _ref9.sortable, dragRect = _ref9.dragRect;
                    if (multiDragElements.length > 1) {
                        multiDragElements.forEach((function(multiDragElement) {
                            sortable.addAnimationState({
                                target: multiDragElement,
                                rect: folding ? getRect(multiDragElement) : dragRect
                            });
                            unsetRect(multiDragElement);
                            multiDragElement.fromRect = dragRect;
                            fromSortable.removeAnimationState(multiDragElement);
                        }));
                        folding = false;
                        insertMultiDragElements(!this.options.removeCloneOnHide, rootEl);
                    }
                },
                dragOverCompleted: function dragOverCompleted(_ref10) {
                    var sortable = _ref10.sortable, isOwner = _ref10.isOwner, insertion = _ref10.insertion, activeSortable = _ref10.activeSortable, parentEl = _ref10.parentEl, putSortable = _ref10.putSortable;
                    var options = this.options;
                    if (insertion) {
                        if (isOwner) {
                            activeSortable._hideClone();
                        }
                        initialFolding = false;
                        if (options.animation && multiDragElements.length > 1 && (folding || !isOwner && !activeSortable.options.sort && !putSortable)) {
                            var dragRectAbsolute = getRect(dragEl$1, false, true, true);
                            multiDragElements.forEach((function(multiDragElement) {
                                if (multiDragElement === dragEl$1) return;
                                setRect(multiDragElement, dragRectAbsolute);
                                parentEl.appendChild(multiDragElement);
                            }));
                            folding = true;
                        }
                        if (!isOwner) {
                            if (!folding) {
                                removeMultiDragElements();
                            }
                            if (multiDragElements.length > 1) {
                                var clonesHiddenBefore = clonesHidden;
                                activeSortable._showClone(sortable);
                                if (activeSortable.options.animation && !clonesHidden && clonesHiddenBefore) {
                                    multiDragClones.forEach((function(clone) {
                                        activeSortable.addAnimationState({
                                            target: clone,
                                            rect: clonesFromRect
                                        });
                                        clone.fromRect = clonesFromRect;
                                        clone.thisAnimationDuration = null;
                                    }));
                                }
                            } else {
                                activeSortable._showClone(sortable);
                            }
                        }
                    }
                },
                dragOverAnimationCapture: function dragOverAnimationCapture(_ref11) {
                    var dragRect = _ref11.dragRect, isOwner = _ref11.isOwner, activeSortable = _ref11.activeSortable;
                    multiDragElements.forEach((function(multiDragElement) {
                        multiDragElement.thisAnimationDuration = null;
                    }));
                    if (activeSortable.options.animation && !isOwner && activeSortable.multiDrag.isMultiDrag) {
                        clonesFromRect = _extends({}, dragRect);
                        var dragMatrix = matrix(dragEl$1, true);
                        clonesFromRect.top -= dragMatrix.f;
                        clonesFromRect.left -= dragMatrix.e;
                    }
                },
                dragOverAnimationComplete: function dragOverAnimationComplete() {
                    if (folding) {
                        folding = false;
                        removeMultiDragElements();
                    }
                },
                drop: function drop(_ref12) {
                    var evt = _ref12.originalEvent, rootEl = _ref12.rootEl, parentEl = _ref12.parentEl, sortable = _ref12.sortable, dispatchSortableEvent = _ref12.dispatchSortableEvent, oldIndex = _ref12.oldIndex, putSortable = _ref12.putSortable;
                    var toSortable = putSortable || this.sortable;
                    if (!evt) return;
                    var options = this.options, children = parentEl.children;
                    if (!dragStarted) {
                        if (options.multiDragKey && !this.multiDragKeyDown) {
                            this._deselectMultiDrag();
                        }
                        toggleClass(dragEl$1, options.selectedClass, !~multiDragElements.indexOf(dragEl$1));
                        if (!~multiDragElements.indexOf(dragEl$1)) {
                            multiDragElements.push(dragEl$1);
                            dispatchEvent({
                                sortable,
                                rootEl,
                                name: "select",
                                targetEl: dragEl$1,
                                originalEvent: evt
                            });
                            if (evt.shiftKey && lastMultiDragSelect && sortable.el.contains(lastMultiDragSelect)) {
                                var lastIndex = index(lastMultiDragSelect), currentIndex = index(dragEl$1);
                                if (~lastIndex && ~currentIndex && lastIndex !== currentIndex) {
                                    var n, i;
                                    if (currentIndex > lastIndex) {
                                        i = lastIndex;
                                        n = currentIndex;
                                    } else {
                                        i = currentIndex;
                                        n = lastIndex + 1;
                                    }
                                    for (;i < n; i++) {
                                        if (~multiDragElements.indexOf(children[i])) continue;
                                        toggleClass(children[i], options.selectedClass, true);
                                        multiDragElements.push(children[i]);
                                        dispatchEvent({
                                            sortable,
                                            rootEl,
                                            name: "select",
                                            targetEl: children[i],
                                            originalEvent: evt
                                        });
                                    }
                                }
                            } else {
                                lastMultiDragSelect = dragEl$1;
                            }
                            multiDragSortable = toSortable;
                        } else {
                            multiDragElements.splice(multiDragElements.indexOf(dragEl$1), 1);
                            lastMultiDragSelect = null;
                            dispatchEvent({
                                sortable,
                                rootEl,
                                name: "deselect",
                                targetEl: dragEl$1,
                                originalEvent: evt
                            });
                        }
                    }
                    if (dragStarted && this.isMultiDrag) {
                        folding = false;
                        if ((parentEl[expando].options.sort || parentEl !== rootEl) && multiDragElements.length > 1) {
                            var dragRect = getRect(dragEl$1), multiDragIndex = index(dragEl$1, ":not(." + this.options.selectedClass + ")");
                            if (!initialFolding && options.animation) dragEl$1.thisAnimationDuration = null;
                            toSortable.captureAnimationState();
                            if (!initialFolding) {
                                if (options.animation) {
                                    dragEl$1.fromRect = dragRect;
                                    multiDragElements.forEach((function(multiDragElement) {
                                        multiDragElement.thisAnimationDuration = null;
                                        if (multiDragElement !== dragEl$1) {
                                            var rect = folding ? getRect(multiDragElement) : dragRect;
                                            multiDragElement.fromRect = rect;
                                            toSortable.addAnimationState({
                                                target: multiDragElement,
                                                rect
                                            });
                                        }
                                    }));
                                }
                                removeMultiDragElements();
                                multiDragElements.forEach((function(multiDragElement) {
                                    if (children[multiDragIndex]) {
                                        parentEl.insertBefore(multiDragElement, children[multiDragIndex]);
                                    } else {
                                        parentEl.appendChild(multiDragElement);
                                    }
                                    multiDragIndex++;
                                }));
                                if (oldIndex === index(dragEl$1)) {
                                    var update = false;
                                    multiDragElements.forEach((function(multiDragElement) {
                                        if (multiDragElement.sortableIndex !== index(multiDragElement)) {
                                            update = true;
                                            return;
                                        }
                                    }));
                                    if (update) {
                                        dispatchSortableEvent("update");
                                    }
                                }
                            }
                            multiDragElements.forEach((function(multiDragElement) {
                                unsetRect(multiDragElement);
                            }));
                            toSortable.animateAll();
                        }
                        multiDragSortable = toSortable;
                    }
                    if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== "clone") {
                        multiDragClones.forEach((function(clone) {
                            clone.parentNode && clone.parentNode.removeChild(clone);
                        }));
                    }
                },
                nullingGlobal: function nullingGlobal() {
                    this.isMultiDrag = dragStarted = false;
                    multiDragClones.length = 0;
                },
                destroyGlobal: function destroyGlobal() {
                    this._deselectMultiDrag();
                    off(document, "pointerup", this._deselectMultiDrag);
                    off(document, "mouseup", this._deselectMultiDrag);
                    off(document, "touchend", this._deselectMultiDrag);
                    off(document, "keydown", this._checkKeyDown);
                    off(document, "keyup", this._checkKeyUp);
                },
                _deselectMultiDrag: function _deselectMultiDrag(evt) {
                    if (typeof dragStarted !== "undefined" && dragStarted) return;
                    if (multiDragSortable !== this.sortable) return;
                    if (evt && closest(evt.target, this.options.draggable, this.sortable.el, false)) return;
                    if (evt && evt.button !== 0) return;
                    while (multiDragElements.length) {
                        var el = multiDragElements[0];
                        toggleClass(el, this.options.selectedClass, false);
                        multiDragElements.shift();
                        dispatchEvent({
                            sortable: this.sortable,
                            rootEl: this.sortable.el,
                            name: "deselect",
                            targetEl: el,
                            originalEvent: evt
                        });
                    }
                },
                _checkKeyDown: function _checkKeyDown(evt) {
                    if (evt.key === this.options.multiDragKey) {
                        this.multiDragKeyDown = true;
                    }
                },
                _checkKeyUp: function _checkKeyUp(evt) {
                    if (evt.key === this.options.multiDragKey) {
                        this.multiDragKeyDown = false;
                    }
                }
            };
            return _extends(MultiDrag, {
                pluginName: "multiDrag",
                utils: {
                    select: function select(el) {
                        var sortable = el.parentNode[expando];
                        if (!sortable || !sortable.options.multiDrag || ~multiDragElements.indexOf(el)) return;
                        if (multiDragSortable && multiDragSortable !== sortable) {
                            multiDragSortable.multiDrag._deselectMultiDrag();
                            multiDragSortable = sortable;
                        }
                        toggleClass(el, sortable.options.selectedClass, true);
                        multiDragElements.push(el);
                    },
                    deselect: function deselect(el) {
                        var sortable = el.parentNode[expando], index = multiDragElements.indexOf(el);
                        if (!sortable || !sortable.options.multiDrag || !~index) return;
                        toggleClass(el, sortable.options.selectedClass, false);
                        multiDragElements.splice(index, 1);
                    }
                },
                eventProperties: function eventProperties() {
                    var _this3 = this;
                    var oldIndicies = [], newIndicies = [];
                    multiDragElements.forEach((function(multiDragElement) {
                        oldIndicies.push({
                            multiDragElement,
                            index: multiDragElement.sortableIndex
                        });
                        var newIndex;
                        if (folding && multiDragElement !== dragEl$1) {
                            newIndex = -1;
                        } else if (folding) {
                            newIndex = index(multiDragElement, ":not(." + _this3.options.selectedClass + ")");
                        } else {
                            newIndex = index(multiDragElement);
                        }
                        newIndicies.push({
                            multiDragElement,
                            index: newIndex
                        });
                    }));
                    return {
                        items: _toConsumableArray(multiDragElements),
                        clones: [].concat(multiDragClones),
                        oldIndicies,
                        newIndicies
                    };
                },
                optionListeners: {
                    multiDragKey: function multiDragKey(key) {
                        key = key.toLowerCase();
                        if (key === "ctrl") {
                            key = "Control";
                        } else if (key.length > 1) {
                            key = key.charAt(0).toUpperCase() + key.substr(1);
                        }
                        return key;
                    }
                }
            });
        }
        function insertMultiDragElements(clonesInserted, rootEl) {
            multiDragElements.forEach((function(multiDragElement, i) {
                var target = rootEl.children[multiDragElement.sortableIndex + (clonesInserted ? Number(i) : 0)];
                if (target) {
                    rootEl.insertBefore(multiDragElement, target);
                } else {
                    rootEl.appendChild(multiDragElement);
                }
            }));
        }
        function insertMultiDragClones(elementsInserted, rootEl) {
            multiDragClones.forEach((function(clone, i) {
                var target = rootEl.children[clone.sortableIndex + (elementsInserted ? Number(i) : 0)];
                if (target) {
                    rootEl.insertBefore(clone, target);
                } else {
                    rootEl.appendChild(clone);
                }
            }));
        }
        function removeMultiDragElements() {
            multiDragElements.forEach((function(multiDragElement) {
                if (multiDragElement === dragEl$1) return;
                multiDragElement.parentNode && multiDragElement.parentNode.removeChild(multiDragElement);
            }));
        }
        Sortable.mount(new AutoScrollPlugin);
        Sortable.mount(Remove, Revert);
        const __WEBPACK_DEFAULT_EXPORT__ = Sortable;
    }, (module, exports) => {
        var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
        /*!
  Copyright (c) 2018 Jed Watson.
  Licensed under the MIT License (MIT), see
  http://jedwatson.github.io/classnames
*/        (function() {
            "use strict";
            var hasOwn = {}.hasOwnProperty;
            function classNames() {
                var classes = [];
                for (var i = 0; i < arguments.length; i++) {
                    var arg = arguments[i];
                    if (!arg) continue;
                    var argType = typeof arg;
                    if (argType === "string" || argType === "number") {
                        classes.push(arg);
                    } else if (Array.isArray(arg)) {
                        if (arg.length) {
                            var inner = classNames.apply(null, arg);
                            if (inner) {
                                classes.push(inner);
                            }
                        }
                    } else if (argType === "object") {
                        if (arg.toString === Object.prototype.toString) {
                            for (var key in arg) {
                                if (hasOwn.call(arg, key) && arg[key]) {
                                    classes.push(key);
                                }
                            }
                        } else {
                            classes.push(arg.toString());
                        }
                    }
                }
                return classes.join(" ");
            }
            if (true && module.exports) {
                classNames.default = classNames;
                module.exports = classNames;
            } else if (true) {
                !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
                    return classNames;
                }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
            } else {}
        })();
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => invariant
        });
        var isProduction = "development" === "production";
        var prefix = "Invariant failed";
        function invariant(condition, message) {
            if (condition) {
                return;
            }
            if (isProduction) {
                throw new Error(prefix);
            }
            var provided = typeof message === "function" ? message() : message;
            var value = provided ? prefix + ": " + provided : prefix;
            throw new Error(value);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var react_window__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(285);
        var _icons__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(277);
        var _state_popup__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(190);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var ListItem = function(_Component) {
            _inherits(ListItem, _Component);
            var _super = _createSuper(ListItem);
            function ListItem() {
                _classCallCheck(this, ListItem);
                return _super.apply(this, arguments);
            }
            _createClass(ListItem, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, style = _this$props.style, data = _this$props.data, index = _this$props.index, onSelect = _this$props.onSelect;
                    var item = data[index];
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
                        className: "select-list-item",
                        style,
                        onClick: function onClick() {
                            return onSelect(item.id);
                        },
                        children: item.label
                    });
                }
            } ]);
            return ListItem;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var Dropdown = function(_Component2) {
            _inherits(Dropdown, _Component2);
            var _super2 = _createSuper(Dropdown);
            function Dropdown() {
                var _this;
                _classCallCheck(this, Dropdown);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super2.call.apply(_super2, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    keyword: ""
                });
                return _this;
            }
            _createClass(Dropdown, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props2 = this.props, items = _this$props2.items, width = _this$props2.width, onSelect = _this$props2.onSelect;
                    var keyword = this.state.keyword.toLowerCase();
                    var filteredItems = items.filter((function(item) {
                        return item.label.toLowerCase().indexOf(keyword) !== -1;
                    }));
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("label", {
                            className: "dropdown-search-label",
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("input", {
                                value: this.state.keyword,
                                className: "dropdown-search",
                                type: "text",
                                placeholder: "Type to search...",
                                onChange: function onChange(e) {
                                    _this2.setState({
                                        keyword: e.target.value
                                    });
                                }
                            })
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(react_window__WEBPACK_IMPORTED_MODULE_4__.FixedSizeList, {
                            width,
                            height: 200,
                            itemCount: filteredItems.length,
                            itemSize: 36,
                            itemData: filteredItems,
                            children: function children(props) {
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(ListItem, _objectSpread({
                                    onSelect
                                }, props));
                            }
                        }) ]
                    });
                }
            } ]);
            return Dropdown;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var ReactSelect = function(_Component3) {
            _inherits(ReactSelect, _Component3);
            var _super3 = _createSuper(ReactSelect);
            function ReactSelect() {
                var _this3;
                _classCallCheck(this, ReactSelect);
                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                    args[_key2] = arguments[_key2];
                }
                _this3 = _super3.call.apply(_super3, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this3), "changePopup", (function() {
                    return null;
                }));
                return _this3;
            }
            _createClass(ReactSelect, [ {
                key: "render",
                value: function render() {
                    var _this4 = this;
                    var _this$props3 = this.props, items = _this$props3.items, width = _this$props3.width, value = _this$props3.value, _onSelect = _this$props3.onSelect, filters = _this$props3.filters;
                    var $this = this;
                    var listItems = Object.keys(items).filter((function(item) {
                        if (filters) {
                            return filters.indexOf(item) === -1;
                        }
                        return true;
                    })).map((function(item) {
                        return {
                            id: item,
                            label: _typeof(items[item]) === "object" ? items[item].label : items[item]
                        };
                    }));
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
                        className: "lotta-react-select",
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_state_popup__WEBPACK_IMPORTED_MODULE_2__["default"], {
                            arrow: false,
                            content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(Dropdown, {
                                width: width || 260,
                                items: listItems,
                                onSelect: function onSelect(id) {
                                    _onSelect(id);
                                    $this.changePopup(false);
                                }
                            }),
                            children: function children(_ref) {
                                var setIsOpen = _ref.setIsOpen, props = _ref.props;
                                _this4.changePopup = setIsOpen;
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", _objectSpread(_objectSpread({}, props), {}, {
                                    className: "select-input",
                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("span", {
                                        children: _typeof(items[value]) === "object" ? items[value].label : items[value]
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.DownAngle, {}) ]
                                }));
                            }
                        })
                    });
                }
            } ]);
            return ReactSelect;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = ReactSelect;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            FixedSizeGrid: () => FixedSizeGrid,
            FixedSizeList: () => FixedSizeList,
            VariableSizeGrid: () => VariableSizeGrid,
            VariableSizeList: () => VariableSizeList,
            areEqual: () => areEqual,
            shouldComponentUpdate: () => shouldComponentUpdate
        });
        var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(286);
        var _babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(287);
        var _babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(288);
        var memoize_one__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(291);
        var react__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_3__);
        var _babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(290);
        var hasNativePerformanceNow = typeof performance === "object" && typeof performance.now === "function";
        var now = hasNativePerformanceNow ? function() {
            return performance.now();
        } : function() {
            return Date.now();
        };
        function cancelTimeout(timeoutID) {
            cancelAnimationFrame(timeoutID.id);
        }
        function requestTimeout(callback, delay) {
            var start = now();
            function tick() {
                if (now() - start >= delay) {
                    callback.call(null);
                } else {
                    timeoutID.id = requestAnimationFrame(tick);
                }
            }
            var timeoutID = {
                id: requestAnimationFrame(tick)
            };
            return timeoutID;
        }
        var size = -1;
        function getScrollbarSize(recalculate) {
            if (recalculate === void 0) {
                recalculate = false;
            }
            if (size === -1 || recalculate) {
                var div = document.createElement("div");
                var style = div.style;
                style.width = "50px";
                style.height = "50px";
                style.overflow = "scroll";
                document.body.appendChild(div);
                size = div.offsetWidth - div.clientWidth;
                document.body.removeChild(div);
            }
            return size;
        }
        var cachedRTLResult = null;
        function getRTLOffsetType(recalculate) {
            if (recalculate === void 0) {
                recalculate = false;
            }
            if (cachedRTLResult === null || recalculate) {
                var outerDiv = document.createElement("div");
                var outerStyle = outerDiv.style;
                outerStyle.width = "50px";
                outerStyle.height = "50px";
                outerStyle.overflow = "scroll";
                outerStyle.direction = "rtl";
                var innerDiv = document.createElement("div");
                var innerStyle = innerDiv.style;
                innerStyle.width = "100px";
                innerStyle.height = "100px";
                outerDiv.appendChild(innerDiv);
                document.body.appendChild(outerDiv);
                if (outerDiv.scrollLeft > 0) {
                    cachedRTLResult = "positive-descending";
                } else {
                    outerDiv.scrollLeft = 1;
                    if (outerDiv.scrollLeft === 0) {
                        cachedRTLResult = "negative";
                    } else {
                        cachedRTLResult = "positive-ascending";
                    }
                }
                document.body.removeChild(outerDiv);
                return cachedRTLResult;
            }
            return cachedRTLResult;
        }
        var IS_SCROLLING_DEBOUNCE_INTERVAL = 150;
        var defaultItemKey = function defaultItemKey(_ref) {
            var columnIndex = _ref.columnIndex, data = _ref.data, rowIndex = _ref.rowIndex;
            return rowIndex + ":" + columnIndex;
        };
        var devWarningsOverscanCount = null;
        var devWarningsOverscanRowsColumnsCount = null;
        var devWarningsTagName = null;
        if (true) {
            if (typeof window !== "undefined" && typeof window.WeakSet !== "undefined") {
                devWarningsOverscanCount = new WeakSet;
                devWarningsOverscanRowsColumnsCount = new WeakSet;
                devWarningsTagName = new WeakSet;
            }
        }
        function createGridComponent(_ref2) {
            var _class;
            var getColumnOffset = _ref2.getColumnOffset, getColumnStartIndexForOffset = _ref2.getColumnStartIndexForOffset, getColumnStopIndexForStartIndex = _ref2.getColumnStopIndexForStartIndex, getColumnWidth = _ref2.getColumnWidth, getEstimatedTotalHeight = _ref2.getEstimatedTotalHeight, getEstimatedTotalWidth = _ref2.getEstimatedTotalWidth, getOffsetForColumnAndAlignment = _ref2.getOffsetForColumnAndAlignment, getOffsetForRowAndAlignment = _ref2.getOffsetForRowAndAlignment, getRowHeight = _ref2.getRowHeight, getRowOffset = _ref2.getRowOffset, getRowStartIndexForOffset = _ref2.getRowStartIndexForOffset, getRowStopIndexForStartIndex = _ref2.getRowStopIndexForStartIndex, initInstanceProps = _ref2.initInstanceProps, shouldResetStyleCacheOnItemSizeChange = _ref2.shouldResetStyleCacheOnItemSizeChange, validateProps = _ref2.validateProps;
            return _class = function(_PureComponent) {
                (0, _babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_2__["default"])(Grid, _PureComponent);
                function Grid(props) {
                    var _this;
                    _this = _PureComponent.call(this, props) || this;
                    _this._instanceProps = initInstanceProps(_this.props, (0, _babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__["default"])(_this));
                    _this._resetIsScrollingTimeoutId = null;
                    _this._outerRef = void 0;
                    _this.state = {
                        instance: (0, _babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__["default"])(_this),
                        isScrolling: false,
                        horizontalScrollDirection: "forward",
                        scrollLeft: typeof _this.props.initialScrollLeft === "number" ? _this.props.initialScrollLeft : 0,
                        scrollTop: typeof _this.props.initialScrollTop === "number" ? _this.props.initialScrollTop : 0,
                        scrollUpdateWasRequested: false,
                        verticalScrollDirection: "forward"
                    };
                    _this._callOnItemsRendered = void 0;
                    _this._callOnItemsRendered = (0, memoize_one__WEBPACK_IMPORTED_MODULE_5__["default"])((function(overscanColumnStartIndex, overscanColumnStopIndex, overscanRowStartIndex, overscanRowStopIndex, visibleColumnStartIndex, visibleColumnStopIndex, visibleRowStartIndex, visibleRowStopIndex) {
                        return _this.props.onItemsRendered({
                            overscanColumnStartIndex,
                            overscanColumnStopIndex,
                            overscanRowStartIndex,
                            overscanRowStopIndex,
                            visibleColumnStartIndex,
                            visibleColumnStopIndex,
                            visibleRowStartIndex,
                            visibleRowStopIndex
                        });
                    }));
                    _this._callOnScroll = void 0;
                    _this._callOnScroll = (0, memoize_one__WEBPACK_IMPORTED_MODULE_5__["default"])((function(scrollLeft, scrollTop, horizontalScrollDirection, verticalScrollDirection, scrollUpdateWasRequested) {
                        return _this.props.onScroll({
                            horizontalScrollDirection,
                            scrollLeft,
                            scrollTop,
                            verticalScrollDirection,
                            scrollUpdateWasRequested
                        });
                    }));
                    _this._getItemStyle = void 0;
                    _this._getItemStyle = function(rowIndex, columnIndex) {
                        var _this$props = _this.props, columnWidth = _this$props.columnWidth, direction = _this$props.direction, rowHeight = _this$props.rowHeight;
                        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && columnWidth, shouldResetStyleCacheOnItemSizeChange && direction, shouldResetStyleCacheOnItemSizeChange && rowHeight);
                        var key = rowIndex + ":" + columnIndex;
                        var style;
                        if (itemStyleCache.hasOwnProperty(key)) {
                            style = itemStyleCache[key];
                        } else {
                            var _offset = getColumnOffset(_this.props, columnIndex, _this._instanceProps);
                            var isRtl = direction === "rtl";
                            itemStyleCache[key] = style = {
                                position: "absolute",
                                left: isRtl ? undefined : _offset,
                                right: isRtl ? _offset : undefined,
                                top: getRowOffset(_this.props, rowIndex, _this._instanceProps),
                                height: getRowHeight(_this.props, rowIndex, _this._instanceProps),
                                width: getColumnWidth(_this.props, columnIndex, _this._instanceProps)
                            };
                        }
                        return style;
                    };
                    _this._getItemStyleCache = void 0;
                    _this._getItemStyleCache = (0, memoize_one__WEBPACK_IMPORTED_MODULE_5__["default"])((function(_, __, ___) {
                        return {};
                    }));
                    _this._onScroll = function(event) {
                        var _event$currentTarget = event.currentTarget, clientHeight = _event$currentTarget.clientHeight, clientWidth = _event$currentTarget.clientWidth, scrollLeft = _event$currentTarget.scrollLeft, scrollTop = _event$currentTarget.scrollTop, scrollHeight = _event$currentTarget.scrollHeight, scrollWidth = _event$currentTarget.scrollWidth;
                        _this.setState((function(prevState) {
                            if (prevState.scrollLeft === scrollLeft && prevState.scrollTop === scrollTop) {
                                return null;
                            }
                            var direction = _this.props.direction;
                            var calculatedScrollLeft = scrollLeft;
                            if (direction === "rtl") {
                                switch (getRTLOffsetType()) {
                                  case "negative":
                                    calculatedScrollLeft = -scrollLeft;
                                    break;

                                  case "positive-descending":
                                    calculatedScrollLeft = scrollWidth - clientWidth - scrollLeft;
                                    break;
                                }
                            }
                            calculatedScrollLeft = Math.max(0, Math.min(calculatedScrollLeft, scrollWidth - clientWidth));
                            var calculatedScrollTop = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
                            return {
                                isScrolling: true,
                                horizontalScrollDirection: prevState.scrollLeft < scrollLeft ? "forward" : "backward",
                                scrollLeft: calculatedScrollLeft,
                                scrollTop: calculatedScrollTop,
                                verticalScrollDirection: prevState.scrollTop < scrollTop ? "forward" : "backward",
                                scrollUpdateWasRequested: false
                            };
                        }), _this._resetIsScrollingDebounced);
                    };
                    _this._outerRefSetter = function(ref) {
                        var outerRef = _this.props.outerRef;
                        _this._outerRef = ref;
                        if (typeof outerRef === "function") {
                            outerRef(ref);
                        } else if (outerRef != null && typeof outerRef === "object" && outerRef.hasOwnProperty("current")) {
                            outerRef.current = ref;
                        }
                    };
                    _this._resetIsScrollingDebounced = function() {
                        if (_this._resetIsScrollingTimeoutId !== null) {
                            cancelTimeout(_this._resetIsScrollingTimeoutId);
                        }
                        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL);
                    };
                    _this._resetIsScrolling = function() {
                        _this._resetIsScrollingTimeoutId = null;
                        _this.setState({
                            isScrolling: false
                        }, (function() {
                            _this._getItemStyleCache(-1);
                        }));
                    };
                    return _this;
                }
                Grid.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
                    validateSharedProps(nextProps, prevState);
                    validateProps(nextProps);
                    return null;
                };
                var _proto = Grid.prototype;
                _proto.scrollTo = function scrollTo(_ref3) {
                    var scrollLeft = _ref3.scrollLeft, scrollTop = _ref3.scrollTop;
                    if (scrollLeft !== undefined) {
                        scrollLeft = Math.max(0, scrollLeft);
                    }
                    if (scrollTop !== undefined) {
                        scrollTop = Math.max(0, scrollTop);
                    }
                    this.setState((function(prevState) {
                        if (scrollLeft === undefined) {
                            scrollLeft = prevState.scrollLeft;
                        }
                        if (scrollTop === undefined) {
                            scrollTop = prevState.scrollTop;
                        }
                        if (prevState.scrollLeft === scrollLeft && prevState.scrollTop === scrollTop) {
                            return null;
                        }
                        return {
                            horizontalScrollDirection: prevState.scrollLeft < scrollLeft ? "forward" : "backward",
                            scrollLeft,
                            scrollTop,
                            scrollUpdateWasRequested: true,
                            verticalScrollDirection: prevState.scrollTop < scrollTop ? "forward" : "backward"
                        };
                    }), this._resetIsScrollingDebounced);
                };
                _proto.scrollToItem = function scrollToItem(_ref4) {
                    var _ref4$align = _ref4.align, align = _ref4$align === void 0 ? "auto" : _ref4$align, columnIndex = _ref4.columnIndex, rowIndex = _ref4.rowIndex;
                    var _this$props2 = this.props, columnCount = _this$props2.columnCount, height = _this$props2.height, rowCount = _this$props2.rowCount, width = _this$props2.width;
                    var _this$state = this.state, scrollLeft = _this$state.scrollLeft, scrollTop = _this$state.scrollTop;
                    var scrollbarSize = getScrollbarSize();
                    if (columnIndex !== undefined) {
                        columnIndex = Math.max(0, Math.min(columnIndex, columnCount - 1));
                    }
                    if (rowIndex !== undefined) {
                        rowIndex = Math.max(0, Math.min(rowIndex, rowCount - 1));
                    }
                    var estimatedTotalHeight = getEstimatedTotalHeight(this.props, this._instanceProps);
                    var estimatedTotalWidth = getEstimatedTotalWidth(this.props, this._instanceProps);
                    var horizontalScrollbarSize = estimatedTotalWidth > width ? scrollbarSize : 0;
                    var verticalScrollbarSize = estimatedTotalHeight > height ? scrollbarSize : 0;
                    this.scrollTo({
                        scrollLeft: columnIndex !== undefined ? getOffsetForColumnAndAlignment(this.props, columnIndex, align, scrollLeft, this._instanceProps, verticalScrollbarSize) : scrollLeft,
                        scrollTop: rowIndex !== undefined ? getOffsetForRowAndAlignment(this.props, rowIndex, align, scrollTop, this._instanceProps, horizontalScrollbarSize) : scrollTop
                    });
                };
                _proto.componentDidMount = function componentDidMount() {
                    var _this$props3 = this.props, initialScrollLeft = _this$props3.initialScrollLeft, initialScrollTop = _this$props3.initialScrollTop;
                    if (this._outerRef != null) {
                        var outerRef = this._outerRef;
                        if (typeof initialScrollLeft === "number") {
                            outerRef.scrollLeft = initialScrollLeft;
                        }
                        if (typeof initialScrollTop === "number") {
                            outerRef.scrollTop = initialScrollTop;
                        }
                    }
                    this._callPropsCallbacks();
                };
                _proto.componentDidUpdate = function componentDidUpdate() {
                    var direction = this.props.direction;
                    var _this$state2 = this.state, scrollLeft = _this$state2.scrollLeft, scrollTop = _this$state2.scrollTop, scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;
                    if (scrollUpdateWasRequested && this._outerRef != null) {
                        var outerRef = this._outerRef;
                        if (direction === "rtl") {
                            switch (getRTLOffsetType()) {
                              case "negative":
                                outerRef.scrollLeft = -scrollLeft;
                                break;

                              case "positive-ascending":
                                outerRef.scrollLeft = scrollLeft;
                                break;

                              default:
                                var clientWidth = outerRef.clientWidth, scrollWidth = outerRef.scrollWidth;
                                outerRef.scrollLeft = scrollWidth - clientWidth - scrollLeft;
                                break;
                            }
                        } else {
                            outerRef.scrollLeft = Math.max(0, scrollLeft);
                        }
                        outerRef.scrollTop = Math.max(0, scrollTop);
                    }
                    this._callPropsCallbacks();
                };
                _proto.componentWillUnmount = function componentWillUnmount() {
                    if (this._resetIsScrollingTimeoutId !== null) {
                        cancelTimeout(this._resetIsScrollingTimeoutId);
                    }
                };
                _proto.render = function render() {
                    var _this$props4 = this.props, children = _this$props4.children, className = _this$props4.className, columnCount = _this$props4.columnCount, direction = _this$props4.direction, height = _this$props4.height, innerRef = _this$props4.innerRef, innerElementType = _this$props4.innerElementType, innerTagName = _this$props4.innerTagName, itemData = _this$props4.itemData, _this$props4$itemKey = _this$props4.itemKey, itemKey = _this$props4$itemKey === void 0 ? defaultItemKey : _this$props4$itemKey, outerElementType = _this$props4.outerElementType, outerTagName = _this$props4.outerTagName, rowCount = _this$props4.rowCount, style = _this$props4.style, useIsScrolling = _this$props4.useIsScrolling, width = _this$props4.width;
                    var isScrolling = this.state.isScrolling;
                    var _this$_getHorizontalR = this._getHorizontalRangeToRender(), columnStartIndex = _this$_getHorizontalR[0], columnStopIndex = _this$_getHorizontalR[1];
                    var _this$_getVerticalRan = this._getVerticalRangeToRender(), rowStartIndex = _this$_getVerticalRan[0], rowStopIndex = _this$_getVerticalRan[1];
                    var items = [];
                    if (columnCount > 0 && rowCount) {
                        for (var _rowIndex = rowStartIndex; _rowIndex <= rowStopIndex; _rowIndex++) {
                            for (var _columnIndex = columnStartIndex; _columnIndex <= columnStopIndex; _columnIndex++) {
                                items.push((0, react__WEBPACK_IMPORTED_MODULE_3__.createElement)(children, {
                                    columnIndex: _columnIndex,
                                    data: itemData,
                                    isScrolling: useIsScrolling ? isScrolling : undefined,
                                    key: itemKey({
                                        columnIndex: _columnIndex,
                                        data: itemData,
                                        rowIndex: _rowIndex
                                    }),
                                    rowIndex: _rowIndex,
                                    style: this._getItemStyle(_rowIndex, _columnIndex)
                                }));
                            }
                        }
                    }
                    var estimatedTotalHeight = getEstimatedTotalHeight(this.props, this._instanceProps);
                    var estimatedTotalWidth = getEstimatedTotalWidth(this.props, this._instanceProps);
                    return (0, react__WEBPACK_IMPORTED_MODULE_3__.createElement)(outerElementType || outerTagName || "div", {
                        className,
                        onScroll: this._onScroll,
                        ref: this._outerRefSetter,
                        style: (0, _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__["default"])({
                            position: "relative",
                            height,
                            width,
                            overflow: "auto",
                            WebkitOverflowScrolling: "touch",
                            willChange: "transform",
                            direction
                        }, style)
                    }, (0, react__WEBPACK_IMPORTED_MODULE_3__.createElement)(innerElementType || innerTagName || "div", {
                        children: items,
                        ref: innerRef,
                        style: {
                            height: estimatedTotalHeight,
                            pointerEvents: isScrolling ? "none" : undefined,
                            width: estimatedTotalWidth
                        }
                    }));
                };
                _proto._callPropsCallbacks = function _callPropsCallbacks() {
                    var _this$props5 = this.props, columnCount = _this$props5.columnCount, onItemsRendered = _this$props5.onItemsRendered, onScroll = _this$props5.onScroll, rowCount = _this$props5.rowCount;
                    if (typeof onItemsRendered === "function") {
                        if (columnCount > 0 && rowCount > 0) {
                            var _this$_getHorizontalR2 = this._getHorizontalRangeToRender(), _overscanColumnStartIndex = _this$_getHorizontalR2[0], _overscanColumnStopIndex = _this$_getHorizontalR2[1], _visibleColumnStartIndex = _this$_getHorizontalR2[2], _visibleColumnStopIndex = _this$_getHorizontalR2[3];
                            var _this$_getVerticalRan2 = this._getVerticalRangeToRender(), _overscanRowStartIndex = _this$_getVerticalRan2[0], _overscanRowStopIndex = _this$_getVerticalRan2[1], _visibleRowStartIndex = _this$_getVerticalRan2[2], _visibleRowStopIndex = _this$_getVerticalRan2[3];
                            this._callOnItemsRendered(_overscanColumnStartIndex, _overscanColumnStopIndex, _overscanRowStartIndex, _overscanRowStopIndex, _visibleColumnStartIndex, _visibleColumnStopIndex, _visibleRowStartIndex, _visibleRowStopIndex);
                        }
                    }
                    if (typeof onScroll === "function") {
                        var _this$state3 = this.state, _horizontalScrollDirection = _this$state3.horizontalScrollDirection, _scrollLeft = _this$state3.scrollLeft, _scrollTop = _this$state3.scrollTop, _scrollUpdateWasRequested = _this$state3.scrollUpdateWasRequested, _verticalScrollDirection = _this$state3.verticalScrollDirection;
                        this._callOnScroll(_scrollLeft, _scrollTop, _horizontalScrollDirection, _verticalScrollDirection, _scrollUpdateWasRequested);
                    }
                };
                _proto._getHorizontalRangeToRender = function _getHorizontalRangeToRender() {
                    var _this$props6 = this.props, columnCount = _this$props6.columnCount, overscanColumnCount = _this$props6.overscanColumnCount, overscanColumnsCount = _this$props6.overscanColumnsCount, overscanCount = _this$props6.overscanCount, rowCount = _this$props6.rowCount;
                    var _this$state4 = this.state, horizontalScrollDirection = _this$state4.horizontalScrollDirection, isScrolling = _this$state4.isScrolling, scrollLeft = _this$state4.scrollLeft;
                    var overscanCountResolved = overscanColumnCount || overscanColumnsCount || overscanCount || 1;
                    if (columnCount === 0 || rowCount === 0) {
                        return [ 0, 0, 0, 0 ];
                    }
                    var startIndex = getColumnStartIndexForOffset(this.props, scrollLeft, this._instanceProps);
                    var stopIndex = getColumnStopIndexForStartIndex(this.props, startIndex, scrollLeft, this._instanceProps);
                    var overscanBackward = !isScrolling || horizontalScrollDirection === "backward" ? Math.max(1, overscanCountResolved) : 1;
                    var overscanForward = !isScrolling || horizontalScrollDirection === "forward" ? Math.max(1, overscanCountResolved) : 1;
                    return [ Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(columnCount - 1, stopIndex + overscanForward)), startIndex, stopIndex ];
                };
                _proto._getVerticalRangeToRender = function _getVerticalRangeToRender() {
                    var _this$props7 = this.props, columnCount = _this$props7.columnCount, overscanCount = _this$props7.overscanCount, overscanRowCount = _this$props7.overscanRowCount, overscanRowsCount = _this$props7.overscanRowsCount, rowCount = _this$props7.rowCount;
                    var _this$state5 = this.state, isScrolling = _this$state5.isScrolling, verticalScrollDirection = _this$state5.verticalScrollDirection, scrollTop = _this$state5.scrollTop;
                    var overscanCountResolved = overscanRowCount || overscanRowsCount || overscanCount || 1;
                    if (columnCount === 0 || rowCount === 0) {
                        return [ 0, 0, 0, 0 ];
                    }
                    var startIndex = getRowStartIndexForOffset(this.props, scrollTop, this._instanceProps);
                    var stopIndex = getRowStopIndexForStartIndex(this.props, startIndex, scrollTop, this._instanceProps);
                    var overscanBackward = !isScrolling || verticalScrollDirection === "backward" ? Math.max(1, overscanCountResolved) : 1;
                    var overscanForward = !isScrolling || verticalScrollDirection === "forward" ? Math.max(1, overscanCountResolved) : 1;
                    return [ Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(rowCount - 1, stopIndex + overscanForward)), startIndex, stopIndex ];
                };
                return Grid;
            }(react__WEBPACK_IMPORTED_MODULE_3__.PureComponent), _class.defaultProps = {
                direction: "ltr",
                itemData: undefined,
                useIsScrolling: false
            }, _class;
        }
        var validateSharedProps = function validateSharedProps(_ref5, _ref6) {
            var children = _ref5.children, direction = _ref5.direction, height = _ref5.height, innerTagName = _ref5.innerTagName, outerTagName = _ref5.outerTagName, overscanColumnsCount = _ref5.overscanColumnsCount, overscanCount = _ref5.overscanCount, overscanRowsCount = _ref5.overscanRowsCount, width = _ref5.width;
            var instance = _ref6.instance;
            if (true) {
                if (typeof overscanCount === "number") {
                    if (devWarningsOverscanCount && !devWarningsOverscanCount.has(instance)) {
                        devWarningsOverscanCount.add(instance);
                        console.warn("The overscanCount prop has been deprecated. " + "Please use the overscanColumnCount and overscanRowCount props instead.");
                    }
                }
                if (typeof overscanColumnsCount === "number" || typeof overscanRowsCount === "number") {
                    if (devWarningsOverscanRowsColumnsCount && !devWarningsOverscanRowsColumnsCount.has(instance)) {
                        devWarningsOverscanRowsColumnsCount.add(instance);
                        console.warn("The overscanColumnsCount and overscanRowsCount props have been deprecated. " + "Please use the overscanColumnCount and overscanRowCount props instead.");
                    }
                }
                if (innerTagName != null || outerTagName != null) {
                    if (devWarningsTagName && !devWarningsTagName.has(instance)) {
                        devWarningsTagName.add(instance);
                        console.warn("The innerTagName and outerTagName props have been deprecated. " + "Please use the innerElementType and outerElementType props instead.");
                    }
                }
                if (children == null) {
                    throw Error('An invalid "children" prop has been specified. ' + "Value should be a React component. " + ('"' + (children === null ? "null" : typeof children) + '" was specified.'));
                }
                switch (direction) {
                  case "ltr":
                  case "rtl":
                    break;

                  default:
                    throw Error('An invalid "direction" prop has been specified. ' + 'Value should be either "ltr" or "rtl". ' + ('"' + direction + '" was specified.'));
                }
                if (typeof width !== "number") {
                    throw Error('An invalid "width" prop has been specified. ' + "Grids must specify a number for width. " + ('"' + (width === null ? "null" : typeof width) + '" was specified.'));
                }
                if (typeof height !== "number") {
                    throw Error('An invalid "height" prop has been specified. ' + "Grids must specify a number for height. " + ('"' + (height === null ? "null" : typeof height) + '" was specified.'));
                }
            }
        };
        var DEFAULT_ESTIMATED_ITEM_SIZE = 50;
        var getEstimatedTotalHeight = function getEstimatedTotalHeight(_ref, _ref2) {
            var rowCount = _ref.rowCount;
            var rowMetadataMap = _ref2.rowMetadataMap, estimatedRowHeight = _ref2.estimatedRowHeight, lastMeasuredRowIndex = _ref2.lastMeasuredRowIndex;
            var totalSizeOfMeasuredRows = 0;
            if (lastMeasuredRowIndex >= rowCount) {
                lastMeasuredRowIndex = rowCount - 1;
            }
            if (lastMeasuredRowIndex >= 0) {
                var itemMetadata = rowMetadataMap[lastMeasuredRowIndex];
                totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;
            }
            var numUnmeasuredItems = rowCount - lastMeasuredRowIndex - 1;
            var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedRowHeight;
            return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;
        };
        var getEstimatedTotalWidth = function getEstimatedTotalWidth(_ref3, _ref4) {
            var columnCount = _ref3.columnCount;
            var columnMetadataMap = _ref4.columnMetadataMap, estimatedColumnWidth = _ref4.estimatedColumnWidth, lastMeasuredColumnIndex = _ref4.lastMeasuredColumnIndex;
            var totalSizeOfMeasuredRows = 0;
            if (lastMeasuredColumnIndex >= columnCount) {
                lastMeasuredColumnIndex = columnCount - 1;
            }
            if (lastMeasuredColumnIndex >= 0) {
                var itemMetadata = columnMetadataMap[lastMeasuredColumnIndex];
                totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;
            }
            var numUnmeasuredItems = columnCount - lastMeasuredColumnIndex - 1;
            var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedColumnWidth;
            return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;
        };
        var getItemMetadata = function getItemMetadata(itemType, props, index, instanceProps) {
            var itemMetadataMap, itemSize, lastMeasuredIndex;
            if (itemType === "column") {
                itemMetadataMap = instanceProps.columnMetadataMap;
                itemSize = props.columnWidth;
                lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;
            } else {
                itemMetadataMap = instanceProps.rowMetadataMap;
                itemSize = props.rowHeight;
                lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;
            }
            if (index > lastMeasuredIndex) {
                var offset = 0;
                if (lastMeasuredIndex >= 0) {
                    var itemMetadata = itemMetadataMap[lastMeasuredIndex];
                    offset = itemMetadata.offset + itemMetadata.size;
                }
                for (var i = lastMeasuredIndex + 1; i <= index; i++) {
                    var size = itemSize(i);
                    itemMetadataMap[i] = {
                        offset,
                        size
                    };
                    offset += size;
                }
                if (itemType === "column") {
                    instanceProps.lastMeasuredColumnIndex = index;
                } else {
                    instanceProps.lastMeasuredRowIndex = index;
                }
            }
            return itemMetadataMap[index];
        };
        var findNearestItem = function findNearestItem(itemType, props, instanceProps, offset) {
            var itemMetadataMap, lastMeasuredIndex;
            if (itemType === "column") {
                itemMetadataMap = instanceProps.columnMetadataMap;
                lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;
            } else {
                itemMetadataMap = instanceProps.rowMetadataMap;
                lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;
            }
            var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;
            if (lastMeasuredItemOffset >= offset) {
                return findNearestItemBinarySearch(itemType, props, instanceProps, lastMeasuredIndex, 0, offset);
            } else {
                return findNearestItemExponentialSearch(itemType, props, instanceProps, Math.max(0, lastMeasuredIndex), offset);
            }
        };
        var findNearestItemBinarySearch = function findNearestItemBinarySearch(itemType, props, instanceProps, high, low, offset) {
            while (low <= high) {
                var middle = low + Math.floor((high - low) / 2);
                var currentOffset = getItemMetadata(itemType, props, middle, instanceProps).offset;
                if (currentOffset === offset) {
                    return middle;
                } else if (currentOffset < offset) {
                    low = middle + 1;
                } else if (currentOffset > offset) {
                    high = middle - 1;
                }
            }
            if (low > 0) {
                return low - 1;
            } else {
                return 0;
            }
        };
        var findNearestItemExponentialSearch = function findNearestItemExponentialSearch(itemType, props, instanceProps, index, offset) {
            var itemCount = itemType === "column" ? props.columnCount : props.rowCount;
            var interval = 1;
            while (index < itemCount && getItemMetadata(itemType, props, index, instanceProps).offset < offset) {
                index += interval;
                interval *= 2;
            }
            return findNearestItemBinarySearch(itemType, props, instanceProps, Math.min(index, itemCount - 1), Math.floor(index / 2), offset);
        };
        var getOffsetForIndexAndAlignment = function getOffsetForIndexAndAlignment(itemType, props, index, align, scrollOffset, instanceProps, scrollbarSize) {
            var size = itemType === "column" ? props.width : props.height;
            var itemMetadata = getItemMetadata(itemType, props, index, instanceProps);
            var estimatedTotalSize = itemType === "column" ? getEstimatedTotalWidth(props, instanceProps) : getEstimatedTotalHeight(props, instanceProps);
            var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, itemMetadata.offset));
            var minOffset = Math.max(0, itemMetadata.offset - size + scrollbarSize + itemMetadata.size);
            if (align === "smart") {
                if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
                    align = "auto";
                } else {
                    align = "center";
                }
            }
            switch (align) {
              case "start":
                return maxOffset;

              case "end":
                return minOffset;

              case "center":
                return Math.round(minOffset + (maxOffset - minOffset) / 2);

              case "auto":
              default:
                if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
                    return scrollOffset;
                } else if (minOffset > maxOffset) {
                    return minOffset;
                } else if (scrollOffset < minOffset) {
                    return minOffset;
                } else {
                    return maxOffset;
                }
            }
        };
        var VariableSizeGrid = createGridComponent({
            getColumnOffset: function getColumnOffset(props, index, instanceProps) {
                return getItemMetadata("column", props, index, instanceProps).offset;
            },
            getColumnStartIndexForOffset: function getColumnStartIndexForOffset(props, scrollLeft, instanceProps) {
                return findNearestItem("column", props, instanceProps, scrollLeft);
            },
            getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(props, startIndex, scrollLeft, instanceProps) {
                var columnCount = props.columnCount, width = props.width;
                var itemMetadata = getItemMetadata("column", props, startIndex, instanceProps);
                var maxOffset = scrollLeft + width;
                var offset = itemMetadata.offset + itemMetadata.size;
                var stopIndex = startIndex;
                while (stopIndex < columnCount - 1 && offset < maxOffset) {
                    stopIndex++;
                    offset += getItemMetadata("column", props, stopIndex, instanceProps).size;
                }
                return stopIndex;
            },
            getColumnWidth: function getColumnWidth(props, index, instanceProps) {
                return instanceProps.columnMetadataMap[index].size;
            },
            getEstimatedTotalHeight,
            getEstimatedTotalWidth,
            getOffsetForColumnAndAlignment: function getOffsetForColumnAndAlignment(props, index, align, scrollOffset, instanceProps, scrollbarSize) {
                return getOffsetForIndexAndAlignment("column", props, index, align, scrollOffset, instanceProps, scrollbarSize);
            },
            getOffsetForRowAndAlignment: function getOffsetForRowAndAlignment(props, index, align, scrollOffset, instanceProps, scrollbarSize) {
                return getOffsetForIndexAndAlignment("row", props, index, align, scrollOffset, instanceProps, scrollbarSize);
            },
            getRowOffset: function getRowOffset(props, index, instanceProps) {
                return getItemMetadata("row", props, index, instanceProps).offset;
            },
            getRowHeight: function getRowHeight(props, index, instanceProps) {
                return instanceProps.rowMetadataMap[index].size;
            },
            getRowStartIndexForOffset: function getRowStartIndexForOffset(props, scrollTop, instanceProps) {
                return findNearestItem("row", props, instanceProps, scrollTop);
            },
            getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(props, startIndex, scrollTop, instanceProps) {
                var rowCount = props.rowCount, height = props.height;
                var itemMetadata = getItemMetadata("row", props, startIndex, instanceProps);
                var maxOffset = scrollTop + height;
                var offset = itemMetadata.offset + itemMetadata.size;
                var stopIndex = startIndex;
                while (stopIndex < rowCount - 1 && offset < maxOffset) {
                    stopIndex++;
                    offset += getItemMetadata("row", props, stopIndex, instanceProps).size;
                }
                return stopIndex;
            },
            initInstanceProps: function initInstanceProps(props, instance) {
                var _ref5 = props, estimatedColumnWidth = _ref5.estimatedColumnWidth, estimatedRowHeight = _ref5.estimatedRowHeight;
                var instanceProps = {
                    columnMetadataMap: {},
                    estimatedColumnWidth: estimatedColumnWidth || DEFAULT_ESTIMATED_ITEM_SIZE,
                    estimatedRowHeight: estimatedRowHeight || DEFAULT_ESTIMATED_ITEM_SIZE,
                    lastMeasuredColumnIndex: -1,
                    lastMeasuredRowIndex: -1,
                    rowMetadataMap: {}
                };
                instance.resetAfterColumnIndex = function(columnIndex, shouldForceUpdate) {
                    if (shouldForceUpdate === void 0) {
                        shouldForceUpdate = true;
                    }
                    instance.resetAfterIndices({
                        columnIndex,
                        shouldForceUpdate
                    });
                };
                instance.resetAfterRowIndex = function(rowIndex, shouldForceUpdate) {
                    if (shouldForceUpdate === void 0) {
                        shouldForceUpdate = true;
                    }
                    instance.resetAfterIndices({
                        rowIndex,
                        shouldForceUpdate
                    });
                };
                instance.resetAfterIndices = function(_ref6) {
                    var columnIndex = _ref6.columnIndex, rowIndex = _ref6.rowIndex, _ref6$shouldForceUpda = _ref6.shouldForceUpdate, shouldForceUpdate = _ref6$shouldForceUpda === void 0 ? true : _ref6$shouldForceUpda;
                    if (typeof columnIndex === "number") {
                        instanceProps.lastMeasuredColumnIndex = Math.min(instanceProps.lastMeasuredColumnIndex, columnIndex - 1);
                    }
                    if (typeof rowIndex === "number") {
                        instanceProps.lastMeasuredRowIndex = Math.min(instanceProps.lastMeasuredRowIndex, rowIndex - 1);
                    }
                    instance._getItemStyleCache(-1);
                    if (shouldForceUpdate) {
                        instance.forceUpdate();
                    }
                };
                return instanceProps;
            },
            shouldResetStyleCacheOnItemSizeChange: false,
            validateProps: function validateProps(_ref7) {
                var columnWidth = _ref7.columnWidth, rowHeight = _ref7.rowHeight;
                if (true) {
                    if (typeof columnWidth !== "function") {
                        throw Error('An invalid "columnWidth" prop has been specified. ' + "Value should be a function. " + ('"' + (columnWidth === null ? "null" : typeof columnWidth) + '" was specified.'));
                    } else if (typeof rowHeight !== "function") {
                        throw Error('An invalid "rowHeight" prop has been specified. ' + "Value should be a function. " + ('"' + (rowHeight === null ? "null" : typeof rowHeight) + '" was specified.'));
                    }
                }
            }
        });
        var IS_SCROLLING_DEBOUNCE_INTERVAL$1 = 150;
        var defaultItemKey$1 = function defaultItemKey(index, data) {
            return index;
        };
        var devWarningsDirection = null;
        var devWarningsTagName$1 = null;
        if (true) {
            if (typeof window !== "undefined" && typeof window.WeakSet !== "undefined") {
                devWarningsDirection = new WeakSet;
                devWarningsTagName$1 = new WeakSet;
            }
        }
        function createListComponent(_ref) {
            var _class;
            var getItemOffset = _ref.getItemOffset, getEstimatedTotalSize = _ref.getEstimatedTotalSize, getItemSize = _ref.getItemSize, getOffsetForIndexAndAlignment = _ref.getOffsetForIndexAndAlignment, getStartIndexForOffset = _ref.getStartIndexForOffset, getStopIndexForStartIndex = _ref.getStopIndexForStartIndex, initInstanceProps = _ref.initInstanceProps, shouldResetStyleCacheOnItemSizeChange = _ref.shouldResetStyleCacheOnItemSizeChange, validateProps = _ref.validateProps;
            return _class = function(_PureComponent) {
                (0, _babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_2__["default"])(List, _PureComponent);
                function List(props) {
                    var _this;
                    _this = _PureComponent.call(this, props) || this;
                    _this._instanceProps = initInstanceProps(_this.props, (0, _babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__["default"])(_this));
                    _this._outerRef = void 0;
                    _this._resetIsScrollingTimeoutId = null;
                    _this.state = {
                        instance: (0, _babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__["default"])(_this),
                        isScrolling: false,
                        scrollDirection: "forward",
                        scrollOffset: typeof _this.props.initialScrollOffset === "number" ? _this.props.initialScrollOffset : 0,
                        scrollUpdateWasRequested: false
                    };
                    _this._callOnItemsRendered = void 0;
                    _this._callOnItemsRendered = (0, memoize_one__WEBPACK_IMPORTED_MODULE_5__["default"])((function(overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex) {
                        return _this.props.onItemsRendered({
                            overscanStartIndex,
                            overscanStopIndex,
                            visibleStartIndex,
                            visibleStopIndex
                        });
                    }));
                    _this._callOnScroll = void 0;
                    _this._callOnScroll = (0, memoize_one__WEBPACK_IMPORTED_MODULE_5__["default"])((function(scrollDirection, scrollOffset, scrollUpdateWasRequested) {
                        return _this.props.onScroll({
                            scrollDirection,
                            scrollOffset,
                            scrollUpdateWasRequested
                        });
                    }));
                    _this._getItemStyle = void 0;
                    _this._getItemStyle = function(index) {
                        var _this$props = _this.props, direction = _this$props.direction, itemSize = _this$props.itemSize, layout = _this$props.layout;
                        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && itemSize, shouldResetStyleCacheOnItemSizeChange && layout, shouldResetStyleCacheOnItemSizeChange && direction);
                        var style;
                        if (itemStyleCache.hasOwnProperty(index)) {
                            style = itemStyleCache[index];
                        } else {
                            var _offset = getItemOffset(_this.props, index, _this._instanceProps);
                            var size = getItemSize(_this.props, index, _this._instanceProps);
                            var isHorizontal = direction === "horizontal" || layout === "horizontal";
                            var isRtl = direction === "rtl";
                            var offsetHorizontal = isHorizontal ? _offset : 0;
                            itemStyleCache[index] = style = {
                                position: "absolute",
                                left: isRtl ? undefined : offsetHorizontal,
                                right: isRtl ? offsetHorizontal : undefined,
                                top: !isHorizontal ? _offset : 0,
                                height: !isHorizontal ? size : "100%",
                                width: isHorizontal ? size : "100%"
                            };
                        }
                        return style;
                    };
                    _this._getItemStyleCache = void 0;
                    _this._getItemStyleCache = (0, memoize_one__WEBPACK_IMPORTED_MODULE_5__["default"])((function(_, __, ___) {
                        return {};
                    }));
                    _this._onScrollHorizontal = function(event) {
                        var _event$currentTarget = event.currentTarget, clientWidth = _event$currentTarget.clientWidth, scrollLeft = _event$currentTarget.scrollLeft, scrollWidth = _event$currentTarget.scrollWidth;
                        _this.setState((function(prevState) {
                            if (prevState.scrollOffset === scrollLeft) {
                                return null;
                            }
                            var direction = _this.props.direction;
                            var scrollOffset = scrollLeft;
                            if (direction === "rtl") {
                                switch (getRTLOffsetType()) {
                                  case "negative":
                                    scrollOffset = -scrollLeft;
                                    break;

                                  case "positive-descending":
                                    scrollOffset = scrollWidth - clientWidth - scrollLeft;
                                    break;
                                }
                            }
                            scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
                            return {
                                isScrolling: true,
                                scrollDirection: prevState.scrollOffset < scrollLeft ? "forward" : "backward",
                                scrollOffset,
                                scrollUpdateWasRequested: false
                            };
                        }), _this._resetIsScrollingDebounced);
                    };
                    _this._onScrollVertical = function(event) {
                        var _event$currentTarget2 = event.currentTarget, clientHeight = _event$currentTarget2.clientHeight, scrollHeight = _event$currentTarget2.scrollHeight, scrollTop = _event$currentTarget2.scrollTop;
                        _this.setState((function(prevState) {
                            if (prevState.scrollOffset === scrollTop) {
                                return null;
                            }
                            var scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
                            return {
                                isScrolling: true,
                                scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
                                scrollOffset,
                                scrollUpdateWasRequested: false
                            };
                        }), _this._resetIsScrollingDebounced);
                    };
                    _this._outerRefSetter = function(ref) {
                        var outerRef = _this.props.outerRef;
                        _this._outerRef = ref;
                        if (typeof outerRef === "function") {
                            outerRef(ref);
                        } else if (outerRef != null && typeof outerRef === "object" && outerRef.hasOwnProperty("current")) {
                            outerRef.current = ref;
                        }
                    };
                    _this._resetIsScrollingDebounced = function() {
                        if (_this._resetIsScrollingTimeoutId !== null) {
                            cancelTimeout(_this._resetIsScrollingTimeoutId);
                        }
                        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL$1);
                    };
                    _this._resetIsScrolling = function() {
                        _this._resetIsScrollingTimeoutId = null;
                        _this.setState({
                            isScrolling: false
                        }, (function() {
                            _this._getItemStyleCache(-1, null);
                        }));
                    };
                    return _this;
                }
                List.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
                    validateSharedProps$1(nextProps, prevState);
                    validateProps(nextProps);
                    return null;
                };
                var _proto = List.prototype;
                _proto.scrollTo = function scrollTo(scrollOffset) {
                    scrollOffset = Math.max(0, scrollOffset);
                    this.setState((function(prevState) {
                        if (prevState.scrollOffset === scrollOffset) {
                            return null;
                        }
                        return {
                            scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
                            scrollOffset,
                            scrollUpdateWasRequested: true
                        };
                    }), this._resetIsScrollingDebounced);
                };
                _proto.scrollToItem = function scrollToItem(index, align) {
                    if (align === void 0) {
                        align = "auto";
                    }
                    var itemCount = this.props.itemCount;
                    var scrollOffset = this.state.scrollOffset;
                    index = Math.max(0, Math.min(index, itemCount - 1));
                    this.scrollTo(getOffsetForIndexAndAlignment(this.props, index, align, scrollOffset, this._instanceProps));
                };
                _proto.componentDidMount = function componentDidMount() {
                    var _this$props2 = this.props, direction = _this$props2.direction, initialScrollOffset = _this$props2.initialScrollOffset, layout = _this$props2.layout;
                    if (typeof initialScrollOffset === "number" && this._outerRef != null) {
                        var outerRef = this._outerRef;
                        if (direction === "horizontal" || layout === "horizontal") {
                            outerRef.scrollLeft = initialScrollOffset;
                        } else {
                            outerRef.scrollTop = initialScrollOffset;
                        }
                    }
                    this._callPropsCallbacks();
                };
                _proto.componentDidUpdate = function componentDidUpdate() {
                    var _this$props3 = this.props, direction = _this$props3.direction, layout = _this$props3.layout;
                    var _this$state = this.state, scrollOffset = _this$state.scrollOffset, scrollUpdateWasRequested = _this$state.scrollUpdateWasRequested;
                    if (scrollUpdateWasRequested && this._outerRef != null) {
                        var outerRef = this._outerRef;
                        if (direction === "horizontal" || layout === "horizontal") {
                            if (direction === "rtl") {
                                switch (getRTLOffsetType()) {
                                  case "negative":
                                    outerRef.scrollLeft = -scrollOffset;
                                    break;

                                  case "positive-ascending":
                                    outerRef.scrollLeft = scrollOffset;
                                    break;

                                  default:
                                    var clientWidth = outerRef.clientWidth, scrollWidth = outerRef.scrollWidth;
                                    outerRef.scrollLeft = scrollWidth - clientWidth - scrollOffset;
                                    break;
                                }
                            } else {
                                outerRef.scrollLeft = scrollOffset;
                            }
                        } else {
                            outerRef.scrollTop = scrollOffset;
                        }
                    }
                    this._callPropsCallbacks();
                };
                _proto.componentWillUnmount = function componentWillUnmount() {
                    if (this._resetIsScrollingTimeoutId !== null) {
                        cancelTimeout(this._resetIsScrollingTimeoutId);
                    }
                };
                _proto.render = function render() {
                    var _this$props4 = this.props, children = _this$props4.children, className = _this$props4.className, direction = _this$props4.direction, height = _this$props4.height, innerRef = _this$props4.innerRef, innerElementType = _this$props4.innerElementType, innerTagName = _this$props4.innerTagName, itemCount = _this$props4.itemCount, itemData = _this$props4.itemData, _this$props4$itemKey = _this$props4.itemKey, itemKey = _this$props4$itemKey === void 0 ? defaultItemKey$1 : _this$props4$itemKey, layout = _this$props4.layout, outerElementType = _this$props4.outerElementType, outerTagName = _this$props4.outerTagName, style = _this$props4.style, useIsScrolling = _this$props4.useIsScrolling, width = _this$props4.width;
                    var isScrolling = this.state.isScrolling;
                    var isHorizontal = direction === "horizontal" || layout === "horizontal";
                    var onScroll = isHorizontal ? this._onScrollHorizontal : this._onScrollVertical;
                    var _this$_getRangeToRend = this._getRangeToRender(), startIndex = _this$_getRangeToRend[0], stopIndex = _this$_getRangeToRend[1];
                    var items = [];
                    if (itemCount > 0) {
                        for (var _index = startIndex; _index <= stopIndex; _index++) {
                            items.push((0, react__WEBPACK_IMPORTED_MODULE_3__.createElement)(children, {
                                data: itemData,
                                key: itemKey(_index, itemData),
                                index: _index,
                                isScrolling: useIsScrolling ? isScrolling : undefined,
                                style: this._getItemStyle(_index)
                            }));
                        }
                    }
                    var estimatedTotalSize = getEstimatedTotalSize(this.props, this._instanceProps);
                    return (0, react__WEBPACK_IMPORTED_MODULE_3__.createElement)(outerElementType || outerTagName || "div", {
                        className,
                        onScroll,
                        ref: this._outerRefSetter,
                        style: (0, _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__["default"])({
                            position: "relative",
                            height,
                            width,
                            overflow: "auto",
                            WebkitOverflowScrolling: "touch",
                            willChange: "transform",
                            direction
                        }, style)
                    }, (0, react__WEBPACK_IMPORTED_MODULE_3__.createElement)(innerElementType || innerTagName || "div", {
                        children: items,
                        ref: innerRef,
                        style: {
                            height: isHorizontal ? "100%" : estimatedTotalSize,
                            pointerEvents: isScrolling ? "none" : undefined,
                            width: isHorizontal ? estimatedTotalSize : "100%"
                        }
                    }));
                };
                _proto._callPropsCallbacks = function _callPropsCallbacks() {
                    if (typeof this.props.onItemsRendered === "function") {
                        var itemCount = this.props.itemCount;
                        if (itemCount > 0) {
                            var _this$_getRangeToRend2 = this._getRangeToRender(), _overscanStartIndex = _this$_getRangeToRend2[0], _overscanStopIndex = _this$_getRangeToRend2[1], _visibleStartIndex = _this$_getRangeToRend2[2], _visibleStopIndex = _this$_getRangeToRend2[3];
                            this._callOnItemsRendered(_overscanStartIndex, _overscanStopIndex, _visibleStartIndex, _visibleStopIndex);
                        }
                    }
                    if (typeof this.props.onScroll === "function") {
                        var _this$state2 = this.state, _scrollDirection = _this$state2.scrollDirection, _scrollOffset = _this$state2.scrollOffset, _scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;
                        this._callOnScroll(_scrollDirection, _scrollOffset, _scrollUpdateWasRequested);
                    }
                };
                _proto._getRangeToRender = function _getRangeToRender() {
                    var _this$props5 = this.props, itemCount = _this$props5.itemCount, overscanCount = _this$props5.overscanCount;
                    var _this$state3 = this.state, isScrolling = _this$state3.isScrolling, scrollDirection = _this$state3.scrollDirection, scrollOffset = _this$state3.scrollOffset;
                    if (itemCount === 0) {
                        return [ 0, 0, 0, 0 ];
                    }
                    var startIndex = getStartIndexForOffset(this.props, scrollOffset, this._instanceProps);
                    var stopIndex = getStopIndexForStartIndex(this.props, startIndex, scrollOffset, this._instanceProps);
                    var overscanBackward = !isScrolling || scrollDirection === "backward" ? Math.max(1, overscanCount) : 1;
                    var overscanForward = !isScrolling || scrollDirection === "forward" ? Math.max(1, overscanCount) : 1;
                    return [ Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(itemCount - 1, stopIndex + overscanForward)), startIndex, stopIndex ];
                };
                return List;
            }(react__WEBPACK_IMPORTED_MODULE_3__.PureComponent), _class.defaultProps = {
                direction: "ltr",
                itemData: undefined,
                layout: "vertical",
                overscanCount: 2,
                useIsScrolling: false
            }, _class;
        }
        var validateSharedProps$1 = function validateSharedProps(_ref2, _ref3) {
            var children = _ref2.children, direction = _ref2.direction, height = _ref2.height, layout = _ref2.layout, innerTagName = _ref2.innerTagName, outerTagName = _ref2.outerTagName, width = _ref2.width;
            var instance = _ref3.instance;
            if (true) {
                if (innerTagName != null || outerTagName != null) {
                    if (devWarningsTagName$1 && !devWarningsTagName$1.has(instance)) {
                        devWarningsTagName$1.add(instance);
                        console.warn("The innerTagName and outerTagName props have been deprecated. " + "Please use the innerElementType and outerElementType props instead.");
                    }
                }
                var isHorizontal = direction === "horizontal" || layout === "horizontal";
                switch (direction) {
                  case "horizontal":
                  case "vertical":
                    if (devWarningsDirection && !devWarningsDirection.has(instance)) {
                        devWarningsDirection.add(instance);
                        console.warn('The direction prop should be either "ltr" (default) or "rtl". ' + 'Please use the layout prop to specify "vertical" (default) or "horizontal" orientation.');
                    }
                    break;

                  case "ltr":
                  case "rtl":
                    break;

                  default:
                    throw Error('An invalid "direction" prop has been specified. ' + 'Value should be either "ltr" or "rtl". ' + ('"' + direction + '" was specified.'));
                }
                switch (layout) {
                  case "horizontal":
                  case "vertical":
                    break;

                  default:
                    throw Error('An invalid "layout" prop has been specified. ' + 'Value should be either "horizontal" or "vertical". ' + ('"' + layout + '" was specified.'));
                }
                if (children == null) {
                    throw Error('An invalid "children" prop has been specified. ' + "Value should be a React component. " + ('"' + (children === null ? "null" : typeof children) + '" was specified.'));
                }
                if (isHorizontal && typeof width !== "number") {
                    throw Error('An invalid "width" prop has been specified. ' + "Horizontal lists must specify a number for width. " + ('"' + (width === null ? "null" : typeof width) + '" was specified.'));
                } else if (!isHorizontal && typeof height !== "number") {
                    throw Error('An invalid "height" prop has been specified. ' + "Vertical lists must specify a number for height. " + ('"' + (height === null ? "null" : typeof height) + '" was specified.'));
                }
            }
        };
        var DEFAULT_ESTIMATED_ITEM_SIZE$1 = 50;
        var getItemMetadata$1 = function getItemMetadata(props, index, instanceProps) {
            var _ref = props, itemSize = _ref.itemSize;
            var itemMetadataMap = instanceProps.itemMetadataMap, lastMeasuredIndex = instanceProps.lastMeasuredIndex;
            if (index > lastMeasuredIndex) {
                var offset = 0;
                if (lastMeasuredIndex >= 0) {
                    var itemMetadata = itemMetadataMap[lastMeasuredIndex];
                    offset = itemMetadata.offset + itemMetadata.size;
                }
                for (var i = lastMeasuredIndex + 1; i <= index; i++) {
                    var size = itemSize(i);
                    itemMetadataMap[i] = {
                        offset,
                        size
                    };
                    offset += size;
                }
                instanceProps.lastMeasuredIndex = index;
            }
            return itemMetadataMap[index];
        };
        var findNearestItem$1 = function findNearestItem(props, instanceProps, offset) {
            var itemMetadataMap = instanceProps.itemMetadataMap, lastMeasuredIndex = instanceProps.lastMeasuredIndex;
            var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;
            if (lastMeasuredItemOffset >= offset) {
                return findNearestItemBinarySearch$1(props, instanceProps, lastMeasuredIndex, 0, offset);
            } else {
                return findNearestItemExponentialSearch$1(props, instanceProps, Math.max(0, lastMeasuredIndex), offset);
            }
        };
        var findNearestItemBinarySearch$1 = function findNearestItemBinarySearch(props, instanceProps, high, low, offset) {
            while (low <= high) {
                var middle = low + Math.floor((high - low) / 2);
                var currentOffset = getItemMetadata$1(props, middle, instanceProps).offset;
                if (currentOffset === offset) {
                    return middle;
                } else if (currentOffset < offset) {
                    low = middle + 1;
                } else if (currentOffset > offset) {
                    high = middle - 1;
                }
            }
            if (low > 0) {
                return low - 1;
            } else {
                return 0;
            }
        };
        var findNearestItemExponentialSearch$1 = function findNearestItemExponentialSearch(props, instanceProps, index, offset) {
            var itemCount = props.itemCount;
            var interval = 1;
            while (index < itemCount && getItemMetadata$1(props, index, instanceProps).offset < offset) {
                index += interval;
                interval *= 2;
            }
            return findNearestItemBinarySearch$1(props, instanceProps, Math.min(index, itemCount - 1), Math.floor(index / 2), offset);
        };
        var getEstimatedTotalSize = function getEstimatedTotalSize(_ref2, _ref3) {
            var itemCount = _ref2.itemCount;
            var itemMetadataMap = _ref3.itemMetadataMap, estimatedItemSize = _ref3.estimatedItemSize, lastMeasuredIndex = _ref3.lastMeasuredIndex;
            var totalSizeOfMeasuredItems = 0;
            if (lastMeasuredIndex >= itemCount) {
                lastMeasuredIndex = itemCount - 1;
            }
            if (lastMeasuredIndex >= 0) {
                var itemMetadata = itemMetadataMap[lastMeasuredIndex];
                totalSizeOfMeasuredItems = itemMetadata.offset + itemMetadata.size;
            }
            var numUnmeasuredItems = itemCount - lastMeasuredIndex - 1;
            var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;
            return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
        };
        var VariableSizeList = createListComponent({
            getItemOffset: function getItemOffset(props, index, instanceProps) {
                return getItemMetadata$1(props, index, instanceProps).offset;
            },
            getItemSize: function getItemSize(props, index, instanceProps) {
                return instanceProps.itemMetadataMap[index].size;
            },
            getEstimatedTotalSize,
            getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(props, index, align, scrollOffset, instanceProps) {
                var direction = props.direction, height = props.height, layout = props.layout, width = props.width;
                var isHorizontal = direction === "horizontal" || layout === "horizontal";
                var size = isHorizontal ? width : height;
                var itemMetadata = getItemMetadata$1(props, index, instanceProps);
                var estimatedTotalSize = getEstimatedTotalSize(props, instanceProps);
                var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, itemMetadata.offset));
                var minOffset = Math.max(0, itemMetadata.offset - size + itemMetadata.size);
                if (align === "smart") {
                    if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
                        align = "auto";
                    } else {
                        align = "center";
                    }
                }
                switch (align) {
                  case "start":
                    return maxOffset;

                  case "end":
                    return minOffset;

                  case "center":
                    return Math.round(minOffset + (maxOffset - minOffset) / 2);

                  case "auto":
                  default:
                    if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
                        return scrollOffset;
                    } else if (scrollOffset < minOffset) {
                        return minOffset;
                    } else {
                        return maxOffset;
                    }
                }
            },
            getStartIndexForOffset: function getStartIndexForOffset(props, offset, instanceProps) {
                return findNearestItem$1(props, instanceProps, offset);
            },
            getStopIndexForStartIndex: function getStopIndexForStartIndex(props, startIndex, scrollOffset, instanceProps) {
                var direction = props.direction, height = props.height, itemCount = props.itemCount, layout = props.layout, width = props.width;
                var isHorizontal = direction === "horizontal" || layout === "horizontal";
                var size = isHorizontal ? width : height;
                var itemMetadata = getItemMetadata$1(props, startIndex, instanceProps);
                var maxOffset = scrollOffset + size;
                var offset = itemMetadata.offset + itemMetadata.size;
                var stopIndex = startIndex;
                while (stopIndex < itemCount - 1 && offset < maxOffset) {
                    stopIndex++;
                    offset += getItemMetadata$1(props, stopIndex, instanceProps).size;
                }
                return stopIndex;
            },
            initInstanceProps: function initInstanceProps(props, instance) {
                var _ref4 = props, estimatedItemSize = _ref4.estimatedItemSize;
                var instanceProps = {
                    itemMetadataMap: {},
                    estimatedItemSize: estimatedItemSize || DEFAULT_ESTIMATED_ITEM_SIZE$1,
                    lastMeasuredIndex: -1
                };
                instance.resetAfterIndex = function(index, shouldForceUpdate) {
                    if (shouldForceUpdate === void 0) {
                        shouldForceUpdate = true;
                    }
                    instanceProps.lastMeasuredIndex = Math.min(instanceProps.lastMeasuredIndex, index - 1);
                    instance._getItemStyleCache(-1);
                    if (shouldForceUpdate) {
                        instance.forceUpdate();
                    }
                };
                return instanceProps;
            },
            shouldResetStyleCacheOnItemSizeChange: false,
            validateProps: function validateProps(_ref5) {
                var itemSize = _ref5.itemSize;
                if (true) {
                    if (typeof itemSize !== "function") {
                        throw Error('An invalid "itemSize" prop has been specified. ' + "Value should be a function. " + ('"' + (itemSize === null ? "null" : typeof itemSize) + '" was specified.'));
                    }
                }
            }
        });
        var FixedSizeGrid = createGridComponent({
            getColumnOffset: function getColumnOffset(_ref, index) {
                var columnWidth = _ref.columnWidth;
                return index * columnWidth;
            },
            getColumnWidth: function getColumnWidth(_ref2, index) {
                var columnWidth = _ref2.columnWidth;
                return columnWidth;
            },
            getRowOffset: function getRowOffset(_ref3, index) {
                var rowHeight = _ref3.rowHeight;
                return index * rowHeight;
            },
            getRowHeight: function getRowHeight(_ref4, index) {
                var rowHeight = _ref4.rowHeight;
                return rowHeight;
            },
            getEstimatedTotalHeight: function getEstimatedTotalHeight(_ref5) {
                var rowCount = _ref5.rowCount, rowHeight = _ref5.rowHeight;
                return rowHeight * rowCount;
            },
            getEstimatedTotalWidth: function getEstimatedTotalWidth(_ref6) {
                var columnCount = _ref6.columnCount, columnWidth = _ref6.columnWidth;
                return columnWidth * columnCount;
            },
            getOffsetForColumnAndAlignment: function getOffsetForColumnAndAlignment(_ref7, columnIndex, align, scrollLeft, instanceProps, scrollbarSize) {
                var columnCount = _ref7.columnCount, columnWidth = _ref7.columnWidth, width = _ref7.width;
                var lastColumnOffset = Math.max(0, columnCount * columnWidth - width);
                var maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);
                var minOffset = Math.max(0, columnIndex * columnWidth - width + scrollbarSize + columnWidth);
                if (align === "smart") {
                    if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
                        align = "auto";
                    } else {
                        align = "center";
                    }
                }
                switch (align) {
                  case "start":
                    return maxOffset;

                  case "end":
                    return minOffset;

                  case "center":
                    var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
                    if (middleOffset < Math.ceil(width / 2)) {
                        return 0;
                    } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
                        return lastColumnOffset;
                    } else {
                        return middleOffset;
                    }

                  case "auto":
                  default:
                    if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
                        return scrollLeft;
                    } else if (minOffset > maxOffset) {
                        return minOffset;
                    } else if (scrollLeft < minOffset) {
                        return minOffset;
                    } else {
                        return maxOffset;
                    }
                }
            },
            getOffsetForRowAndAlignment: function getOffsetForRowAndAlignment(_ref8, rowIndex, align, scrollTop, instanceProps, scrollbarSize) {
                var rowHeight = _ref8.rowHeight, height = _ref8.height, rowCount = _ref8.rowCount;
                var lastRowOffset = Math.max(0, rowCount * rowHeight - height);
                var maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);
                var minOffset = Math.max(0, rowIndex * rowHeight - height + scrollbarSize + rowHeight);
                if (align === "smart") {
                    if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
                        align = "auto";
                    } else {
                        align = "center";
                    }
                }
                switch (align) {
                  case "start":
                    return maxOffset;

                  case "end":
                    return minOffset;

                  case "center":
                    var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
                    if (middleOffset < Math.ceil(height / 2)) {
                        return 0;
                    } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
                        return lastRowOffset;
                    } else {
                        return middleOffset;
                    }

                  case "auto":
                  default:
                    if (scrollTop >= minOffset && scrollTop <= maxOffset) {
                        return scrollTop;
                    } else if (minOffset > maxOffset) {
                        return minOffset;
                    } else if (scrollTop < minOffset) {
                        return minOffset;
                    } else {
                        return maxOffset;
                    }
                }
            },
            getColumnStartIndexForOffset: function getColumnStartIndexForOffset(_ref9, scrollLeft) {
                var columnWidth = _ref9.columnWidth, columnCount = _ref9.columnCount;
                return Math.max(0, Math.min(columnCount - 1, Math.floor(scrollLeft / columnWidth)));
            },
            getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(_ref10, startIndex, scrollLeft) {
                var columnWidth = _ref10.columnWidth, columnCount = _ref10.columnCount, width = _ref10.width;
                var left = startIndex * columnWidth;
                var numVisibleColumns = Math.ceil((width + scrollLeft - left) / columnWidth);
                return Math.max(0, Math.min(columnCount - 1, startIndex + numVisibleColumns - 1));
            },
            getRowStartIndexForOffset: function getRowStartIndexForOffset(_ref11, scrollTop) {
                var rowHeight = _ref11.rowHeight, rowCount = _ref11.rowCount;
                return Math.max(0, Math.min(rowCount - 1, Math.floor(scrollTop / rowHeight)));
            },
            getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(_ref12, startIndex, scrollTop) {
                var rowHeight = _ref12.rowHeight, rowCount = _ref12.rowCount, height = _ref12.height;
                var top = startIndex * rowHeight;
                var numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);
                return Math.max(0, Math.min(rowCount - 1, startIndex + numVisibleRows - 1));
            },
            initInstanceProps: function initInstanceProps(props) {},
            shouldResetStyleCacheOnItemSizeChange: true,
            validateProps: function validateProps(_ref13) {
                var columnWidth = _ref13.columnWidth, rowHeight = _ref13.rowHeight;
                if (true) {
                    if (typeof columnWidth !== "number") {
                        throw Error('An invalid "columnWidth" prop has been specified. ' + "Value should be a number. " + ('"' + (columnWidth === null ? "null" : typeof columnWidth) + '" was specified.'));
                    }
                    if (typeof rowHeight !== "number") {
                        throw Error('An invalid "rowHeight" prop has been specified. ' + "Value should be a number. " + ('"' + (rowHeight === null ? "null" : typeof rowHeight) + '" was specified.'));
                    }
                }
            }
        });
        var FixedSizeList = createListComponent({
            getItemOffset: function getItemOffset(_ref, index) {
                var itemSize = _ref.itemSize;
                return index * itemSize;
            },
            getItemSize: function getItemSize(_ref2, index) {
                var itemSize = _ref2.itemSize;
                return itemSize;
            },
            getEstimatedTotalSize: function getEstimatedTotalSize(_ref3) {
                var itemCount = _ref3.itemCount, itemSize = _ref3.itemSize;
                return itemSize * itemCount;
            },
            getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(_ref4, index, align, scrollOffset) {
                var direction = _ref4.direction, height = _ref4.height, itemCount = _ref4.itemCount, itemSize = _ref4.itemSize, layout = _ref4.layout, width = _ref4.width;
                var isHorizontal = direction === "horizontal" || layout === "horizontal";
                var size = isHorizontal ? width : height;
                var lastItemOffset = Math.max(0, itemCount * itemSize - size);
                var maxOffset = Math.min(lastItemOffset, index * itemSize);
                var minOffset = Math.max(0, index * itemSize - size + itemSize);
                if (align === "smart") {
                    if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
                        align = "auto";
                    } else {
                        align = "center";
                    }
                }
                switch (align) {
                  case "start":
                    return maxOffset;

                  case "end":
                    return minOffset;

                  case "center":
                    {
                        var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
                        if (middleOffset < Math.ceil(size / 2)) {
                            return 0;
                        } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
                            return lastItemOffset;
                        } else {
                            return middleOffset;
                        }
                    }

                  case "auto":
                  default:
                    if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
                        return scrollOffset;
                    } else if (scrollOffset < minOffset) {
                        return minOffset;
                    } else {
                        return maxOffset;
                    }
                }
            },
            getStartIndexForOffset: function getStartIndexForOffset(_ref5, offset) {
                var itemCount = _ref5.itemCount, itemSize = _ref5.itemSize;
                return Math.max(0, Math.min(itemCount - 1, Math.floor(offset / itemSize)));
            },
            getStopIndexForStartIndex: function getStopIndexForStartIndex(_ref6, startIndex, scrollOffset) {
                var direction = _ref6.direction, height = _ref6.height, itemCount = _ref6.itemCount, itemSize = _ref6.itemSize, layout = _ref6.layout, width = _ref6.width;
                var isHorizontal = direction === "horizontal" || layout === "horizontal";
                var offset = startIndex * itemSize;
                var size = isHorizontal ? width : height;
                var numVisibleItems = Math.ceil((size + scrollOffset - offset) / itemSize);
                return Math.max(0, Math.min(itemCount - 1, startIndex + numVisibleItems - 1));
            },
            initInstanceProps: function initInstanceProps(props) {},
            shouldResetStyleCacheOnItemSizeChange: true,
            validateProps: function validateProps(_ref7) {
                var itemSize = _ref7.itemSize;
                if (true) {
                    if (typeof itemSize !== "number") {
                        throw Error('An invalid "itemSize" prop has been specified. ' + "Value should be a number. " + ('"' + (itemSize === null ? "null" : typeof itemSize) + '" was specified.'));
                    }
                }
            }
        });
        function shallowDiffers(prev, next) {
            for (var attribute in prev) {
                if (!(attribute in next)) {
                    return true;
                }
            }
            for (var _attribute in next) {
                if (prev[_attribute] !== next[_attribute]) {
                    return true;
                }
            }
            return false;
        }
        var _excluded = [ "style" ], _excluded2 = [ "style" ];
        function areEqual(prevProps, nextProps) {
            var prevStyle = prevProps.style, prevRest = (0, _babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__["default"])(prevProps, _excluded);
            var nextStyle = nextProps.style, nextRest = (0, _babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__["default"])(nextProps, _excluded2);
            return !shallowDiffers(prevStyle, nextStyle) && !shallowDiffers(prevRest, nextRest);
        }
        function shouldComponentUpdate(nextProps, nextState) {
            return !areEqual(this.props, nextProps) || shallowDiffers(this.state, nextState);
        }
    }, (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => _extends
        });
        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);
        }
    }, (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => _assertThisInitialized
        });
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
    }, (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => _inheritsLoose
        });
        var _setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(289);
        function _inheritsLoose(subClass, superClass) {
            subClass.prototype = Object.create(superClass.prototype);
            subClass.prototype.constructor = subClass;
            (0, _setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__["default"])(subClass, superClass);
        }
    }, (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => _setPrototypeOf
        });
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
    }, (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => _objectWithoutPropertiesLoose
        });
        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;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var safeIsNaN = Number.isNaN || function ponyfill(value) {
            return typeof value === "number" && value !== value;
        };
        function isEqual(first, second) {
            if (first === second) {
                return true;
            }
            if (safeIsNaN(first) && safeIsNaN(second)) {
                return true;
            }
            return false;
        }
        function areInputsEqual(newInputs, lastInputs) {
            if (newInputs.length !== lastInputs.length) {
                return false;
            }
            for (var i = 0; i < newInputs.length; i++) {
                if (!isEqual(newInputs[i], lastInputs[i])) {
                    return false;
                }
            }
            return true;
        }
        function memoizeOne(resultFn, isEqual) {
            if (isEqual === void 0) {
                isEqual = areInputsEqual;
            }
            var lastThis;
            var lastArgs = [];
            var lastResult;
            var calledOnce = false;
            function memoized() {
                var newArgs = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    newArgs[_i] = arguments[_i];
                }
                if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {
                    return lastResult;
                }
                lastResult = resultFn.apply(this, newArgs);
                calledOnce = true;
                lastThis = this;
                lastArgs = newArgs;
                return lastResult;
            }
            return memoized;
        }
        const __WEBPACK_DEFAULT_EXPORT__ = memoizeOne;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Placeholder
        });
        var _color_picker__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(189);
        function Placeholder(props) {
            (0, _color_picker__WEBPACK_IMPORTED_MODULE_0__.ColorPickerHooks)(props);
            return null;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var md5__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(294);
        var md5__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(md5__WEBPACK_IMPORTED_MODULE_1__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        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);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        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;
        }
        function useRefCallback(fn, dependencies) {
            var ref = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useRef)(fn);
            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useEffect)((function() {
                ref.current = fn;
            }), [ fn ].concat(_toConsumableArray(dependencies)));
            return (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useCallback)((function() {
                var fn = ref.current;
                return fn();
            }), [ ref ]);
        }
        function Editor(props) {
            var id = props.id, value = props.value, options = props.options, _onChange = props.onChange;
            var el = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useRef)();
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)("".concat(id, "-").concat(md5__WEBPACK_IMPORTED_MODULE_1___default()(Math.random() + "-" + Math.random() + "-" + Math.random()))), _useState2 = _slicedToArray(_useState, 2), editorId = _useState2[0], _ = _useState2[1];
            var correctEditor = function correctEditor() {
                return wp.oldEditor || wp.editor;
            };
            var listener = useRefCallback((function() {
                _onChange(correctEditor().getContent(editorId));
            }), [ editorId, _onChange ]);
            var editorParams = _objectSpread(_objectSpread({
                quicktags: !!options.quicktags,
                mediaButtons: !!options.mediaButtons
            }, options), {}, {
                tinymce: _objectSpread(_objectSpread({
                    toolbar1: "formatselect,styleselect,bold,italic,bullist,numlist,link,alignleft,aligncenter,alignright,wp_adv",
                    toolbar2: "strikethrough,hr,forecolor,pastetext,removeformat,charmap,outdent,indent,undo,redo,wp_help"
                }, _typeof(options.tinymce) === "object" ? options.tinymce : {}), {}, {
                    style_formats_merge: true,
                    style_formats: []
                })
            });
            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useEffect)((function() {
                correctEditor().initialize(editorId, editorParams);
                setTimeout((function() {
                    window.tinymce.editors[editorId] && window.tinymce.editors[editorId].on("change", listener);
                }));
                if (wp.oldEditor) {
                    setTimeout((function() {
                        setTimeout((function() {
                            window.tinymce.editors[editorId].off("change", listener);
                            correctEditor().remove(editorId);
                            correctEditor().initialize(editorId, editorParams);
                            setTimeout((function() {
                                window.tinymce.editors[editorId] && window.tinymce.editors[editorId].on("change", listener);
                            }));
                        }), 300);
                    }), 1e3);
                }
                return function() {
                    if (!window.tinymce.editors[editorId]) return;
                    setTimeout((function() {
                        window.tinymce.editors[editorId].off("change", listener);
                        correctEditor().remove(editorId);
                    }), 300);
                };
            }), []);
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", _objectSpread(_objectSpread({
                className: "lotta-editor"
            }, options.attrs || {}), {}, {
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("textarea", _objectSpread(_objectSpread({
                    id: editorId,
                    ref: el,
                    value,
                    className: "wp-editor-area"
                }, _objectSpread(_objectSpread({}, options.field_attr ? options.field_attr : {}), options.attr && options.attr.placeholder ? {
                    placeholder: options.attr.placeholder
                } : {})), {}, {
                    onChange: function onChange(_ref) {
                        var value = _ref.target.value;
                        return _onChange(value);
                    }
                }))
            }));
        }
        const __WEBPACK_DEFAULT_EXPORT__ = Editor;
    }, (module, __unused_webpack_exports, __webpack_require__) => {
        (function() {
            var crypt = __webpack_require__(295), utf8 = __webpack_require__(296).utf8, isBuffer = __webpack_require__(297), bin = __webpack_require__(296).bin, md5 = function(message, options) {
                if (message.constructor == String) if (options && options.encoding === "binary") message = bin.stringToBytes(message); else message = utf8.stringToBytes(message); else if (isBuffer(message)) message = Array.prototype.slice.call(message, 0); else if (!Array.isArray(message) && message.constructor !== Uint8Array) message = message.toString();
                var m = crypt.bytesToWords(message), l = message.length * 8, a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
                for (var i = 0; i < m.length; i++) {
                    m[i] = (m[i] << 8 | m[i] >>> 24) & 16711935 | (m[i] << 24 | m[i] >>> 8) & 4278255360;
                }
                m[l >>> 5] |= 128 << l % 32;
                m[(l + 64 >>> 9 << 4) + 14] = l;
                var FF = md5._ff, GG = md5._gg, HH = md5._hh, II = md5._ii;
                for (var i = 0; i < m.length; i += 16) {
                    var aa = a, bb = b, cc = c, dd = d;
                    a = FF(a, b, c, d, m[i + 0], 7, -680876936);
                    d = FF(d, a, b, c, m[i + 1], 12, -389564586);
                    c = FF(c, d, a, b, m[i + 2], 17, 606105819);
                    b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
                    a = FF(a, b, c, d, m[i + 4], 7, -176418897);
                    d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
                    c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
                    b = FF(b, c, d, a, m[i + 7], 22, -45705983);
                    a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
                    d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
                    c = FF(c, d, a, b, m[i + 10], 17, -42063);
                    b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
                    a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
                    d = FF(d, a, b, c, m[i + 13], 12, -40341101);
                    c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
                    b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
                    a = GG(a, b, c, d, m[i + 1], 5, -165796510);
                    d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
                    c = GG(c, d, a, b, m[i + 11], 14, 643717713);
                    b = GG(b, c, d, a, m[i + 0], 20, -373897302);
                    a = GG(a, b, c, d, m[i + 5], 5, -701558691);
                    d = GG(d, a, b, c, m[i + 10], 9, 38016083);
                    c = GG(c, d, a, b, m[i + 15], 14, -660478335);
                    b = GG(b, c, d, a, m[i + 4], 20, -405537848);
                    a = GG(a, b, c, d, m[i + 9], 5, 568446438);
                    d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
                    c = GG(c, d, a, b, m[i + 3], 14, -187363961);
                    b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
                    a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
                    d = GG(d, a, b, c, m[i + 2], 9, -51403784);
                    c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
                    b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
                    a = HH(a, b, c, d, m[i + 5], 4, -378558);
                    d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
                    c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
                    b = HH(b, c, d, a, m[i + 14], 23, -35309556);
                    a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
                    d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
                    c = HH(c, d, a, b, m[i + 7], 16, -155497632);
                    b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
                    a = HH(a, b, c, d, m[i + 13], 4, 681279174);
                    d = HH(d, a, b, c, m[i + 0], 11, -358537222);
                    c = HH(c, d, a, b, m[i + 3], 16, -722521979);
                    b = HH(b, c, d, a, m[i + 6], 23, 76029189);
                    a = HH(a, b, c, d, m[i + 9], 4, -640364487);
                    d = HH(d, a, b, c, m[i + 12], 11, -421815835);
                    c = HH(c, d, a, b, m[i + 15], 16, 530742520);
                    b = HH(b, c, d, a, m[i + 2], 23, -995338651);
                    a = II(a, b, c, d, m[i + 0], 6, -198630844);
                    d = II(d, a, b, c, m[i + 7], 10, 1126891415);
                    c = II(c, d, a, b, m[i + 14], 15, -1416354905);
                    b = II(b, c, d, a, m[i + 5], 21, -57434055);
                    a = II(a, b, c, d, m[i + 12], 6, 1700485571);
                    d = II(d, a, b, c, m[i + 3], 10, -1894986606);
                    c = II(c, d, a, b, m[i + 10], 15, -1051523);
                    b = II(b, c, d, a, m[i + 1], 21, -2054922799);
                    a = II(a, b, c, d, m[i + 8], 6, 1873313359);
                    d = II(d, a, b, c, m[i + 15], 10, -30611744);
                    c = II(c, d, a, b, m[i + 6], 15, -1560198380);
                    b = II(b, c, d, a, m[i + 13], 21, 1309151649);
                    a = II(a, b, c, d, m[i + 4], 6, -145523070);
                    d = II(d, a, b, c, m[i + 11], 10, -1120210379);
                    c = II(c, d, a, b, m[i + 2], 15, 718787259);
                    b = II(b, c, d, a, m[i + 9], 21, -343485551);
                    a = a + aa >>> 0;
                    b = b + bb >>> 0;
                    c = c + cc >>> 0;
                    d = d + dd >>> 0;
                }
                return crypt.endian([ a, b, c, d ]);
            };
            md5._ff = function(a, b, c, d, x, s, t) {
                var n = a + (b & c | ~b & d) + (x >>> 0) + t;
                return (n << s | n >>> 32 - s) + b;
            };
            md5._gg = function(a, b, c, d, x, s, t) {
                var n = a + (b & d | c & ~d) + (x >>> 0) + t;
                return (n << s | n >>> 32 - s) + b;
            };
            md5._hh = function(a, b, c, d, x, s, t) {
                var n = a + (b ^ c ^ d) + (x >>> 0) + t;
                return (n << s | n >>> 32 - s) + b;
            };
            md5._ii = function(a, b, c, d, x, s, t) {
                var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
                return (n << s | n >>> 32 - s) + b;
            };
            md5._blocksize = 16;
            md5._digestsize = 16;
            module.exports = function(message, options) {
                if (message === undefined || message === null) throw new Error("Illegal argument " + message);
                var digestbytes = crypt.wordsToBytes(md5(message, options));
                return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
            };
        })();
    }, module => {
        (function() {
            var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
                rotl: function(n, b) {
                    return n << b | n >>> 32 - b;
                },
                rotr: function(n, b) {
                    return n << 32 - b | n >>> b;
                },
                endian: function(n) {
                    if (n.constructor == Number) {
                        return crypt.rotl(n, 8) & 16711935 | crypt.rotl(n, 24) & 4278255360;
                    }
                    for (var i = 0; i < n.length; i++) n[i] = crypt.endian(n[i]);
                    return n;
                },
                randomBytes: function(n) {
                    for (var bytes = []; n > 0; n--) bytes.push(Math.floor(Math.random() * 256));
                    return bytes;
                },
                bytesToWords: function(bytes) {
                    for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8) words[b >>> 5] |= bytes[i] << 24 - b % 32;
                    return words;
                },
                wordsToBytes: function(words) {
                    for (var bytes = [], b = 0; b < words.length * 32; b += 8) bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
                    return bytes;
                },
                bytesToHex: function(bytes) {
                    for (var hex = [], i = 0; i < bytes.length; i++) {
                        hex.push((bytes[i] >>> 4).toString(16));
                        hex.push((bytes[i] & 15).toString(16));
                    }
                    return hex.join("");
                },
                hexToBytes: function(hex) {
                    for (var bytes = [], c = 0; c < hex.length; c += 2) bytes.push(parseInt(hex.substr(c, 2), 16));
                    return bytes;
                },
                bytesToBase64: function(bytes) {
                    for (var base64 = [], i = 0; i < bytes.length; i += 3) {
                        var triplet = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
                        for (var j = 0; j < 4; j++) if (i * 8 + j * 6 <= bytes.length * 8) base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63)); else base64.push("=");
                    }
                    return base64.join("");
                },
                base64ToBytes: function(base64) {
                    base64 = base64.replace(/[^A-Z0-9+\/]/gi, "");
                    for (var bytes = [], i = 0, imod4 = 0; i < base64.length; imod4 = ++i % 4) {
                        if (imod4 == 0) continue;
                        bytes.push((base64map.indexOf(base64.charAt(i - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i)) >>> 6 - imod4 * 2);
                    }
                    return bytes;
                }
            };
            module.exports = crypt;
        })();
    }, module => {
        var charenc = {
            utf8: {
                stringToBytes: function(str) {
                    return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
                },
                bytesToString: function(bytes) {
                    return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
                }
            },
            bin: {
                stringToBytes: function(str) {
                    for (var bytes = [], i = 0; i < str.length; i++) bytes.push(str.charCodeAt(i) & 255);
                    return bytes;
                },
                bytesToString: function(bytes) {
                    for (var str = [], i = 0; i < bytes.length; i++) str.push(String.fromCharCode(bytes[i]));
                    return str.join("");
                }
            }
        };
        module.exports = charenc;
    }, module => {
        /*!
 * Determine if an object is a Buffer
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
 * @license  MIT
 */
        module.exports = function(obj) {
            return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
        };
        function isBuffer(obj) {
            return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
        }
        function isSlowBuffer(obj) {
            return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var clsx__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
        function Info(_ref) {
            var options = _ref.options;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("div", {
                className: (0, clsx__WEBPACK_IMPORTED_MODULE_0__["default"])("lotta-info", "lotta-info-align-" + options.align, {
                    "lotta-info-has-background": options.background
                }),
                dangerouslySetInnerHTML: {
                    __html: options.info
                }
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = Info;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var clsx__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
        function CallToAction(_ref) {
            var options = _ref.options;
            var cta = options.cta, target = options.target, style = options.style, label = options.label;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("div", {
                children: cta === "customize" ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("button", {
                    type: "button",
                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_0__["default"])({
                        "lotta-cta-button": style === "button",
                        "lotta-cta-link": style !== "button"
                    }),
                    onClick: function onClick() {
                        if (window.Lotta && window.Lotta.expand) {
                            window.Lotta.expand(target);
                        }
                    },
                    children: label
                }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("a", {
                    href: target,
                    target: "_blank",
                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_0__["default"])({
                        "lotta-cta-button": style === "button",
                        "lotta-cta-link": style !== "button"
                    }),
                    children: label
                })
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = CallToAction;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__,
            suggestionItemTemplate: () => suggestionItemTemplate,
            tagTemplate: () => tagTemplate
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _yaireo_tagify__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(301);
        var _yaireo_tagify__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(_yaireo_tagify__WEBPACK_IMPORTED_MODULE_1__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function tagTemplate(tagData) {
            return "\n        <tag contenteditable='false'\n                spellcheck='false'\n                tabIndex=\"-1\"\n                class=\"tagify__tag ".concat(tagData["class"] ? tagData["class"] : "", '"\n                ').concat(this.getAttributes(tagData), ">\n            <x title='' class='tagify__tag__removeBtn' role='button' aria-label='remove tag'></x>\n            <div>\n                <span class='tagify__tag-text'>").concat(tagData.label, "</span>\n            </div>\n        </tag>\n    ");
        }
        function suggestionItemTemplate(tagData) {
            return "\n        <div ".concat(this.getAttributes(tagData), "\n            class='tagify__dropdown__item ").concat(tagData["class"] ? tagData["class"] : "", '\'\n            tabindex="0"\n            role="option">\n            <strong>').concat(tagData.label, "</strong>\n        </div>\n    ");
        }
        var Tags = function(_Component) {
            _inherits(Tags, _Component);
            var _super = _createSuper(Tags);
            function Tags() {
                var _this;
                _classCallCheck(this, Tags);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "tagifyRef", (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRef)());
                _defineProperty(_assertThisInitialized(_this), "tagify", null);
                _defineProperty(_assertThisInitialized(_this), "onChange", (function(ev) {
                    var value = ev.target.value ? JSON.parse(ev.target.value).map((function(e) {
                        return e.value;
                    })) : [];
                    _this.props.onChange(value);
                }));
                return _this;
            }
            _createClass(Tags, [ {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    if (this.tagify) {
                        this.tagify.destroy();
                    }
                }
            }, {
                key: "componentDidMount",
                value: function componentDidMount() {
                    if (this.tagifyRef.current) {
                        this.tagify = new (_yaireo_tagify__WEBPACK_IMPORTED_MODULE_1___default())(this.tagifyRef.current, {
                            tagTextProp: "label",
                            skipInvalid: !!this.props.options.enforceWhitelist,
                            enforceWhitelist: !!this.props.options.enforceWhitelist,
                            whitelist: this.props.options.whitelist || [],
                            templates: {
                                tag: tagTemplate,
                                dropdownItem: suggestionItemTemplate
                            },
                            dropdown: {
                                closeOnSelect: false,
                                enabled: 0,
                                searchKeys: [ "value", "label" ]
                            }
                        });
                    }
                }
            }, {
                key: "render",
                value: function render() {
                    var value = this.props.value;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("input", {
                        className: "lotta-tags",
                        ref: this.tagifyRef,
                        type: "text",
                        value,
                        onChange: this.onChange
                    });
                }
            } ]);
            return Tags;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Tags;
    }, function(module) {
        !function(t, e) {
            true ? module.exports = e() : 0;
        }(this, (function() {
            "use strict";
            function t(t, e) {
                var i = Object.keys(t);
                if (Object.getOwnPropertySymbols) {
                    var s = Object.getOwnPropertySymbols(t);
                    e && (s = s.filter((function(e) {
                        return Object.getOwnPropertyDescriptor(t, e).enumerable;
                    }))), i.push.apply(i, s);
                }
                return i;
            }
            function e(e) {
                for (var s = 1; s < arguments.length; s++) {
                    var a = null != arguments[s] ? arguments[s] : {};
                    s % 2 ? t(Object(a), !0).forEach((function(t) {
                        i(e, t, a[t]);
                    })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(a)) : t(Object(a)).forEach((function(t) {
                        Object.defineProperty(e, t, Object.getOwnPropertyDescriptor(a, t));
                    }));
                }
                return e;
            }
            function i(t, e, i) {
                return e in t ? Object.defineProperty(t, e, {
                    value: i,
                    enumerable: !0,
                    configurable: !0,
                    writable: !0
                }) : t[e] = i, t;
            }
            const s = (t, e, i, s) => (t = "" + t, e = "" + e, s && (t = t.trim(), e = e.trim()), 
            i ? t == e : t.toLowerCase() == e.toLowerCase()), a = (t, e) => t && Array.isArray(t) && t.map((t => n(t, e)));
            function n(t, e) {
                var i, s = {};
                for (i in t) e.indexOf(i) < 0 && (s[i] = t[i]);
                return s;
            }
            function o(t) {
                var e = document.createElement("div");
                return t.replace(/\&#?[0-9a-z]+;/gi, (function(t) {
                    return e.innerHTML = t, e.innerText;
                }));
            }
            function r(t) {
                return (new DOMParser).parseFromString(t.trim(), "text/html").body.firstElementChild;
            }
            function l(t, e) {
                for (e = e || "previous"; t = t[e + "Sibling"]; ) if (3 == t.nodeType) return t;
            }
            function d(t) {
                return "string" == typeof t ? t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/`|'/g, "&#039;") : t;
            }
            function h(t) {
                var e = Object.prototype.toString.call(t).split(" ")[1].slice(0, -1);
                return t === Object(t) && "Array" != e && "Function" != e && "RegExp" != e && "HTMLUnknownElement" != e;
            }
            function g(t, e, i) {
                function s(t, e) {
                    for (var i in e) if (e.hasOwnProperty(i)) {
                        if (h(e[i])) {
                            h(t[i]) ? s(t[i], e[i]) : t[i] = Object.assign({}, e[i]);
                            continue;
                        }
                        if (Array.isArray(e[i])) {
                            t[i] = Object.assign([], e[i]);
                            continue;
                        }
                        t[i] = e[i];
                    }
                }
                return t instanceof Object || (t = {}), s(t, e), i && s(t, i), t;
            }
            function p() {
                const t = [], e = {};
                for (let i of arguments) for (let s of i) h(s) ? e[s.value] || (t.push(s), e[s.value] = 1) : t.includes(s) || t.push(s);
                return t;
            }
            function c(t) {
                return String.prototype.normalize ? "string" == typeof t ? t.normalize("NFD").replace(/[\u0300-\u036f]/g, "") : void 0 : t;
            }
            var u = () => /(?=.*chrome)(?=.*android)/i.test(navigator.userAgent);
            function m() {
                return ([ 1e7 ] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (t => (t ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> t / 4).toString(16)));
            }
            function v(t) {
                return t && t.classList && t.classList.contains(this.settings.classNames.tag);
            }
            var f = {
                delimiters: ",",
                pattern: null,
                tagTextProp: "value",
                maxTags: 1 / 0,
                callbacks: {},
                addTagOnBlur: !0,
                duplicates: !1,
                whitelist: [],
                blacklist: [],
                enforceWhitelist: !1,
                userInput: !0,
                keepInvalidTags: !1,
                mixTagsAllowedAfter: /,|\.|\:|\s/,
                mixTagsInterpolator: [ "[[", "]]" ],
                backspace: !0,
                skipInvalid: !1,
                pasteAsTags: !0,
                editTags: {
                    clicks: 2,
                    keepInvalid: !0
                },
                transformTag: () => {},
                trim: !0,
                a11y: {
                    focusableTags: !1
                },
                mixMode: {
                    insertAfterTag: " "
                },
                autoComplete: {
                    enabled: !0,
                    rightKey: !1
                },
                classNames: {
                    namespace: "tagify",
                    mixMode: "tagify--mix",
                    selectMode: "tagify--select",
                    input: "tagify__input",
                    focus: "tagify--focus",
                    tagNoAnimation: "tagify--noAnim",
                    tagInvalid: "tagify--invalid",
                    tagNotAllowed: "tagify--notAllowed",
                    scopeLoading: "tagify--loading",
                    hasMaxTags: "tagify--hasMaxTags",
                    hasNoTags: "tagify--noTags",
                    empty: "tagify--empty",
                    inputInvalid: "tagify__input--invalid",
                    dropdown: "tagify__dropdown",
                    dropdownWrapper: "tagify__dropdown__wrapper",
                    dropdownHeader: "tagify__dropdown__header",
                    dropdownFooter: "tagify__dropdown__footer",
                    dropdownItem: "tagify__dropdown__item",
                    dropdownItemActive: "tagify__dropdown__item--active",
                    dropdownInital: "tagify__dropdown--initial",
                    tag: "tagify__tag",
                    tagText: "tagify__tag-text",
                    tagX: "tagify__tag__removeBtn",
                    tagLoading: "tagify__tag--loading",
                    tagEditing: "tagify__tag--editable",
                    tagFlash: "tagify__tag--flash",
                    tagHide: "tagify__tag--hide"
                },
                dropdown: {
                    classname: "",
                    enabled: 2,
                    maxItems: 10,
                    searchKeys: [ "value", "searchBy" ],
                    fuzzySearch: !0,
                    caseSensitive: !1,
                    accentedSearch: !0,
                    highlightFirst: !1,
                    closeOnSelect: !0,
                    clearOnSelect: !0,
                    position: "all",
                    appendTarget: null
                },
                hooks: {
                    beforeRemoveTag: () => Promise.resolve(),
                    beforePaste: () => Promise.resolve(),
                    suggestionClick: () => Promise.resolve()
                }
            };
            function T() {
                this.dropdown = {};
                for (let t in this._dropdown) this.dropdown[t] = "function" == typeof this._dropdown[t] ? this._dropdown[t].bind(this) : this._dropdown[t];
                this.dropdown.refs();
            }
            var w = {
                refs() {
                    this.DOM.dropdown = this.parseTemplate("dropdown", [ this.settings ]), this.DOM.dropdown.content = this.DOM.dropdown.querySelector("[data-selector='tagify-dropdown-wrapper']");
                },
                show(t) {
                    var e, i, a, n = this.settings, o = "mix" == n.mode && !n.enforceWhitelist, r = !n.whitelist || !n.whitelist.length, l = "manual" == n.dropdown.position;
                    if (t = void 0 === t ? this.state.inputText : t, (!r || o || n.templates.dropdownItemNoMatch) && !1 !== n.dropdown.enable && !this.state.isLoading) {
                        if (clearTimeout(this.dropdownHide__bindEventsTimeout), this.suggestedListItems = this.dropdown.filterListItems(t), 
                        t && !this.suggestedListItems.length && (this.trigger("dropdown:noMatch", t), n.templates.dropdownItemNoMatch && (a = n.templates.dropdownItemNoMatch.call(this, {
                            value: t
                        }))), !a) {
                            if (this.suggestedListItems.length) t && o && !this.state.editing.scope && !s(this.suggestedListItems[0].value, t) && this.suggestedListItems.unshift({
                                value: t
                            }); else {
                                if (!t || !o || this.state.editing.scope) return this.input.autocomplete.suggest.call(this), 
                                void this.dropdown.hide();
                                this.suggestedListItems = [ {
                                    value: t
                                } ];
                            }
                            i = "" + (h(e = this.suggestedListItems[0]) ? e.value : e), n.autoComplete && i && 0 == i.indexOf(t) && this.input.autocomplete.suggest.call(this, e);
                        }
                        this.dropdown.fill(a), n.dropdown.highlightFirst && this.dropdown.highlightOption(this.DOM.dropdown.content.children[0]), 
                        this.state.dropdown.visible || setTimeout(this.dropdown.events.binding.bind(this)), 
                        this.state.dropdown.visible = t || !0, this.state.dropdown.query = t, this.setStateSelection(), 
                        l || setTimeout((() => {
                            this.dropdown.position(), this.dropdown.render();
                        })), setTimeout((() => {
                            this.trigger("dropdown:show", this.DOM.dropdown);
                        }));
                    }
                },
                hide(t) {
                    var e = this.DOM, i = e.scope, s = e.dropdown, a = "manual" == this.settings.dropdown.position && !t;
                    if (s && document.body.contains(s) && !a) return window.removeEventListener("resize", this.dropdown.position), 
                    this.dropdown.events.binding.call(this, !1), i.setAttribute("aria-expanded", !1), 
                    s.parentNode.removeChild(s), setTimeout((() => {
                        this.state.dropdown.visible = !1;
                    }), 100), this.state.dropdown.query = this.state.ddItemData = this.state.ddItemElm = this.state.selection = null, 
                    this.state.tag && this.state.tag.value.length && (this.state.flaggedTags[this.state.tag.baseOffset] = this.state.tag), 
                    this.trigger("dropdown:hide", s), this;
                },
                toggle(t) {
                    this.dropdown[this.state.dropdown.visible && !t ? "hide" : "show"]();
                },
                render() {
                    var t, e, i, s = (t = this.DOM.dropdown, (i = t.cloneNode(!0)).style.cssText = "position:fixed; top:-9999px; opacity:0", 
                    document.body.appendChild(i), e = i.clientHeight, i.parentNode.removeChild(i), e), a = this.settings;
                    return "number" == typeof a.dropdown.enabled && a.dropdown.enabled >= 0 ? (this.DOM.scope.setAttribute("aria-expanded", !0), 
                    document.body.contains(this.DOM.dropdown) || (this.DOM.dropdown.classList.add(a.classNames.dropdownInital), 
                    this.dropdown.position(s), a.dropdown.appendTarget.appendChild(this.DOM.dropdown), 
                    setTimeout((() => this.DOM.dropdown.classList.remove(a.classNames.dropdownInital)))), 
                    this) : this;
                },
                fill(t) {
                    t = "string" == typeof t ? t : this.dropdown.createListHTML(t || this.suggestedListItems);
                    var e, i = this.settings.templates.dropdownContent.call(this, t);
                    this.DOM.dropdown.content.innerHTML = (e = i) ? e.replace(/\>[\r\n ]+\</g, "><").replace(/(<.*?>)|\s+/g, ((t, e) => e || " ")) : "";
                },
                refilter(t) {
                    t = t || this.state.dropdown.query || "", this.suggestedListItems = this.dropdown.filterListItems(t), 
                    this.dropdown.fill(), this.suggestedListItems.length || this.dropdown.hide(), this.trigger("dropdown:updated", this.DOM.dropdown);
                },
                position(t) {
                    var e = this.settings.dropdown;
                    if ("manual" != e.position) {
                        var i, s, a, n, o, r, l = this.DOM.dropdown, d = e.placeAbove, h = document.documentElement.clientHeight, g = Math.max(document.documentElement.clientWidth || 0, window.innerWidth || 0) > 480 ? e.position : "all", p = this.DOM["input" == g ? "input" : "scope"];
                        t = t || l.clientHeight, this.state.dropdown.visible && ("text" == g ? (a = (i = this.getCaretGlobalPosition()).bottom, 
                        s = i.top, n = i.left, o = "auto") : (r = function(t) {
                            for (var e = 0, i = 0; t; ) e += t.offsetLeft || 0, i += t.offsetTop || 0, t = t.parentNode;
                            return {
                                left: e,
                                top: i
                            };
                        }(this.settings.dropdown.appendTarget), s = (i = p.getBoundingClientRect()).top - r.top, 
                        a = i.bottom - 1 - r.top, n = i.left - r.left, o = i.width + "px"), s = Math.floor(s), 
                        a = Math.ceil(a), d = void 0 === d ? h - i.bottom < t : d, l.style.cssText = "left:" + (n + window.pageXOffset) + "px; width:" + o + ";" + (d ? "top: " + (s + window.pageYOffset) + "px" : "top: " + (a + window.pageYOffset) + "px"), 
                        l.setAttribute("placement", d ? "top" : "bottom"), l.setAttribute("position", g));
                    }
                },
                events: {
                    binding(t = !0) {
                        var e = this.dropdown.events.callbacks, i = this.listeners.dropdown = this.listeners.dropdown || {
                            position: this.dropdown.position.bind(this),
                            onKeyDown: e.onKeyDown.bind(this),
                            onMouseOver: e.onMouseOver.bind(this),
                            onMouseLeave: e.onMouseLeave.bind(this),
                            onClick: e.onClick.bind(this),
                            onScroll: e.onScroll.bind(this)
                        }, s = t ? "addEventListener" : "removeEventListener";
                        "manual" != this.settings.dropdown.position && (window[s]("resize", i.position), 
                        window[s]("keydown", i.onKeyDown)), this.DOM.dropdown[s]("mouseover", i.onMouseOver), 
                        this.DOM.dropdown[s]("mouseleave", i.onMouseLeave), this.DOM.dropdown[s]("mousedown", i.onClick), 
                        this.DOM.dropdown.content[s]("scroll", i.onScroll);
                    },
                    callbacks: {
                        onKeyDown(t) {
                            var e = this.DOM.dropdown.querySelector(this.settings.classNames.dropdownItemActiveSelector), i = this.dropdown.getSuggestionDataByNode(e);
                            switch (t.key) {
                              case "ArrowDown":
                              case "ArrowUp":
                              case "Down":
                              case "Up":
                                var s;
                                t.preventDefault(), e && (e = e[("ArrowUp" == t.key || "Up" == t.key ? "previous" : "next") + "ElementSibling"]), 
                                e || (s = this.DOM.dropdown.content.children, e = s["ArrowUp" == t.key || "Up" == t.key ? s.length - 1 : 0]), 
                                i = this.dropdown.getSuggestionDataByNode(e), this.dropdown.highlightOption(e, !0);
                                break;

                              case "Escape":
                              case "Esc":
                                this.dropdown.hide();
                                break;

                              case "ArrowRight":
                                if (this.state.actions.ArrowLeft) return;

                              case "Tab":
                                if ("mix" != this.settings.mode && e && !this.settings.autoComplete.rightKey && !this.state.editing) {
                                    t.preventDefault();
                                    var a = this.dropdown.getMappedValue(i);
                                    return this.input.autocomplete.set.call(this, a), !1;
                                }
                                return !0;

                              case "Enter":
                                t.preventDefault(), this.settings.hooks.suggestionClick(t, {
                                    tagify: this,
                                    tagData: i,
                                    suggestionElm: e
                                }).then((() => {
                                    if (e) return this.dropdown.selectOption(e);
                                    this.dropdown.hide(), "mix" != this.settings.mode && this.addTags(this.state.inputText.trim(), !0);
                                })).catch((t => t));
                                break;

                              case "Backspace":
                                {
                                    if ("mix" == this.settings.mode || this.state.editing.scope) return;
                                    const t = this.input.raw.call(this);
                                    "" != t && 8203 != t.charCodeAt(0) || (!0 === this.settings.backspace ? this.removeTags() : "edit" == this.settings.backspace && setTimeout(this.editTag.bind(this), 0));
                                }
                            }
                        },
                        onMouseOver(t) {
                            var e = t.target.closest(this.settings.classNames.dropdownItemSelector);
                            e && this.dropdown.highlightOption(e);
                        },
                        onMouseLeave(t) {
                            this.dropdown.highlightOption();
                        },
                        onClick(t) {
                            if (0 == t.button && t.target != this.DOM.dropdown && t.target != this.DOM.dropdown.content) {
                                var e = t.target.closest(this.settings.classNames.dropdownItemSelector), i = this.dropdown.getSuggestionDataByNode(e);
                                this.state.actions.selectOption = !0, setTimeout((() => this.state.actions.selectOption = !1), 50), 
                                this.settings.hooks.suggestionClick(t, {
                                    tagify: this,
                                    tagData: i,
                                    suggestionElm: e
                                }).then((() => {
                                    e ? this.dropdown.selectOption(e) : this.dropdown.hide();
                                })).catch((t => console.warn(t)));
                            }
                        },
                        onScroll(t) {
                            var e = t.target, i = e.scrollTop / (e.scrollHeight - e.parentNode.clientHeight) * 100;
                            this.trigger("dropdown:scroll", {
                                percentage: Math.round(i)
                            });
                        }
                    }
                },
                getSuggestionDataByNode(t) {
                    var e = t ? +t.getAttribute("tagifySuggestionIdx") : -1;
                    return this.suggestedListItems[e] || null;
                },
                highlightOption(t, e) {
                    var i, s = this.settings.classNames.dropdownItemActive;
                    if (this.state.ddItemElm && (this.state.ddItemElm.classList.remove(s), this.state.ddItemElm.removeAttribute("aria-selected")), 
                    !t) return this.state.ddItemData = null, this.state.ddItemElm = null, void this.input.autocomplete.suggest.call(this);
                    i = this.suggestedListItems[this.getNodeIndex(t)], this.state.ddItemData = i, this.state.ddItemElm = t, 
                    t.classList.add(s), t.setAttribute("aria-selected", !0), e && (t.parentNode.scrollTop = t.clientHeight + t.offsetTop - t.parentNode.clientHeight), 
                    this.settings.autoComplete && (this.input.autocomplete.suggest.call(this, i), this.dropdown.position());
                },
                selectOption(t) {
                    var e = this.settings.dropdown, i = e.clearOnSelect, s = e.closeOnSelect;
                    if (!t) return this.addTags(this.state.inputText, !0), void (s && this.dropdown.hide());
                    var a = t.getAttribute("tagifySuggestionIdx"), n = this.suggestedListItems[+a];
                    this.trigger("dropdown:select", {
                        data: n,
                        elm: t
                    }), a && n ? (this.state.editing ? this.onEditTagDone(null, g({
                        __isValid: !0
                    }, this.normalizeTags([ n ])[0])) : this["mix" == this.settings.mode ? "addMixTags" : "addTags"]([ n ], i), 
                    this.DOM.input.parentNode && (setTimeout((() => {
                        this.DOM.input.focus(), this.toggleFocusClass(!0);
                    })), s ? setTimeout(this.dropdown.hide.bind(this)) : this.dropdown.refilter())) : this.dropdown.hide();
                },
                selectAll(t) {
                    this.suggestedListItems.length = 0, this.dropdown.hide(), this.dropdown.filterListItems("");
                    var e = this.dropdown.filterListItems("");
                    return t || (e = this.state.dropdown.suggestions), this.addTags(e, !0), this;
                },
                filterListItems(t, e) {
                    var i, s, a, n, o, r = this.settings, l = r.dropdown, d = (e = e || {}, t = "select" == r.mode && this.value.length && this.value[0][r.tagTextProp] == t ? "" : t, 
                    []), g = [], p = r.whitelist, u = l.maxItems >= 0 ? l.maxItems : 1 / 0, m = l.searchKeys, v = 0;
                    if (!t || !m.length) return d = r.duplicates ? p : p.filter((t => !this.isTagDuplicate(h(t) ? t.value : t))), 
                    this.state.dropdown.suggestions = d, d.slice(0, u);
                    function f(t, e) {
                        return e.toLowerCase().split(" ").every((e => t.includes(e.toLowerCase())));
                    }
                    for (o = l.caseSensitive ? "" + t : ("" + t).toLowerCase(); v < p.length; v++) {
                        let t, u;
                        i = p[v] instanceof Object ? p[v] : {
                            value: p[v]
                        };
                        let T = !Object.keys(i).some((t => m.includes(t))) ? [ "value" ] : m;
                        l.fuzzySearch && !e.exact ? (a = T.reduce(((t, e) => t + " " + (i[e] || "")), "").toLowerCase().trim(), 
                        l.accentedSearch && (a = c(a), o = c(o)), t = 0 == a.indexOf(o), u = a === o, s = f(a, o)) : (t = !0, 
                        s = T.some((t => {
                            var s = "" + (i[t] || "");
                            return l.accentedSearch && (s = c(s), o = c(o)), l.caseSensitive || (s = s.toLowerCase()), 
                            u = s === o, e.exact ? s === o : 0 == s.indexOf(o);
                        }))), n = !r.duplicates && this.isTagDuplicate(h(i) ? i.value : i), s && !n && (u && t ? g.push(i) : "startsWith" == l.sortby && t ? d.unshift(i) : d.push(i));
                    }
                    return this.state.dropdown.suggestions = g.concat(d), "function" == typeof l.sortby ? l.sortby(g.concat(d), o) : g.concat(d).slice(0, u);
                },
                getMappedValue(t) {
                    var e = this.settings.dropdown.mapValueTo;
                    return e ? "function" == typeof e ? e(t) : t[e] || t.value : t.value;
                },
                createListHTML(t) {
                    return g([], t).map(((t, e) => {
                        "string" != typeof t && "number" != typeof t || (t = {
                            value: t
                        });
                        var i = this.dropdown.getMappedValue(t);
                        t.value = "string" == typeof i ? d(i) : i;
                        var s = this.settings.templates.dropdownItem.apply(this, [ t, this ]);
                        return s = s.replace(/\s*tagifySuggestionIdx=(["'])(.*?)\1/gim, "").replace(">", ` tagifySuggestionIdx="${e}">`);
                    })).join("");
                }
            };
            const b = "@yaireo/tagify/";
            var y, x = {
                empty: "empty",
                exceed: "number of tags exceeded",
                pattern: "pattern mismatch",
                duplicate: "already exists",
                notAllowed: "not allowed"
            }, D = {
                wrapper: (t, e) => `<tags class="${e.classNames.namespace} ${e.mode ? `${e.classNames[e.mode + "Mode"]}` : ""} ${t.className}"\n                    ${e.readonly ? "readonly" : ""}\n                    ${e.disabled ? "disabled" : ""}\n                    ${e.required ? "required" : ""}\n                    ${"select" === e.mode ? "spellcheck='false'" : ""}\n                    tabIndex="-1">\n            <span ${!e.readonly && e.userInput ? "contenteditable" : ""} tabIndex="0" data-placeholder="${e.placeholder || "&#8203;"}" aria-placeholder="${e.placeholder || ""}"\n                class="${e.classNames.input}"\n                role="textbox"\n                aria-autocomplete="both"\n                aria-multiline="${"mix" == e.mode}"></span>\n                &#8203;\n        </tags>`,
                tag(t, e) {
                    var i = this.settings;
                    return `<tag title="${t.title || t.value}"\n                    contenteditable='false'\n                    spellcheck='false'\n                    tabIndex="${i.a11y.focusableTags ? 0 : -1}"\n                    class="${i.classNames.tag} ${t.class || ""}"\n                    ${this.getAttributes(t)}>\n            <x title='' class="${i.classNames.tagX}" role='button' aria-label='remove tag'></x>\n            <div>\n                <span class="${i.classNames.tagText}">${t[i.tagTextProp] || t.value}</span>\n            </div>\n        </tag>`;
                },
                dropdown(t) {
                    var e = t.dropdown, i = "manual" == e.position, s = `${t.classNames.dropdown}`;
                    return `<div class="${i ? "" : s} ${e.classname}" role="listbox" aria-labelledby="dropdown">\n                    <div data-selector='tagify-dropdown-wrapper' class="${t.classNames.dropdownWrapper}"></div>\n                </div>`;
                },
                dropdownContent(t) {
                    var e = this.settings, i = this.state.dropdown.suggestions;
                    return `\n            ${e.templates.dropdownHeader.call(this, i)}\n            ${t}\n            ${e.templates.dropdownFooter.call(this, i)}\n        `;
                },
                dropdownItem(t, e) {
                    return `<div ${this.getAttributes(t)}\n                    class='${this.settings.classNames.dropdownItem} ${t.class ? t.class : ""}'\n                    tabindex="0"\n                    role="option">${t.value}</div>`;
                },
                dropdownHeader: t => "",
                dropdownFooter(t) {
                    var e = t.length - this.settings.dropdown.maxItems;
                    return e > 0 ? `<footer data-selector='tagify-suggestions-footer' class="${this.settings.classNames.dropdownFooter}">\n                ${e} more items. Refine your search.\n            </footer>` : "";
                },
                dropdownItemNoMatch: null
            };
            var O = {
                customBinding() {
                    this.customEventsList.forEach((t => {
                        this.on(t, this.settings.callbacks[t]);
                    }));
                },
                binding(t = !0) {
                    var e, i = this.events.callbacks, s = t ? "addEventListener" : "removeEventListener";
                    if (!this.state.mainEvents || !t) {
                        for (var a in this.state.mainEvents = t, t && !this.listeners.main && (this.events.bindGlobal.call(this), 
                        this.settings.isJQueryPlugin && jQuery(this.DOM.originalInput).on("tagify.removeAllTags", this.removeAllTags.bind(this))), 
                        e = this.listeners.main = this.listeners.main || {
                            focus: [ "input", i.onFocusBlur.bind(this) ],
                            keydown: [ "input", i.onKeydown.bind(this) ],
                            click: [ "scope", i.onClickScope.bind(this) ],
                            dblclick: [ "scope", i.onDoubleClickScope.bind(this) ],
                            paste: [ "input", i.onPaste.bind(this) ],
                            drop: [ "input", i.onDrop.bind(this) ]
                        }) this.DOM[e[a][0]][s](a, e[a][1]);
                        clearInterval(this.listeners.main.originalInputValueObserverInterval), this.listeners.main.originalInputValueObserverInterval = setInterval(i.observeOriginalInputValue.bind(this), 500);
                        var n = this.listeners.main.inputMutationObserver || new MutationObserver(i.onInputDOMChange.bind(this));
                        n && n.disconnect(), "mix" == this.settings.mode && n.observe(this.DOM.input, {
                            childList: !0
                        });
                    }
                },
                bindGlobal(t) {
                    var e, i = this.events.callbacks, s = t ? "removeEventListener" : "addEventListener";
                    if (t || !this.listeners.global) for (e of (this.listeners.global = this.listeners && this.listeners.global || [ {
                        type: this.isIE ? "keydown" : "input",
                        target: this.DOM.input,
                        cb: i[this.isIE ? "onInputIE" : "onInput"].bind(this)
                    }, {
                        type: "keydown",
                        target: window,
                        cb: i.onWindowKeyDown.bind(this)
                    }, {
                        type: "blur",
                        target: this.DOM.input,
                        cb: i.onFocusBlur.bind(this)
                    } ], this.listeners.global)) e.target[s](e.type, e.cb);
                },
                unbindGlobal() {
                    this.events.bindGlobal.call(this, !0);
                },
                callbacks: {
                    onFocusBlur(t) {
                        var e = t.target ? this.trim(t.target.textContent) : "", i = this.settings, s = t.type, a = i.dropdown.enabled >= 0, n = {
                            relatedTarget: t.relatedTarget
                        }, o = this.state.actions.selectOption && (a || !i.dropdown.closeOnSelect), r = this.state.actions.addNew && a, l = t.relatedTarget && v.call(this, t.relatedTarget) && this.DOM.scope.contains(t.relatedTarget);
                        if ("blur" == s) {
                            if (t.relatedTarget === this.DOM.scope) return this.dropdown.hide(), void this.DOM.input.focus();
                            this.postUpdate(), this.triggerChangeEvent();
                        }
                        if (!o && !r) if (this.state.hasFocus = "focus" == s && +new Date, this.toggleFocusClass(this.state.hasFocus), 
                        "mix" != i.mode) {
                            if ("focus" == s) return this.trigger("focus", n), void (0 !== i.dropdown.enabled && i.userInput || this.dropdown.show(this.value.length ? "" : void 0));
                            if ("blur" == s) {
                                var d, h;
                                this.trigger("blur", n), this.loading(!1);
                                let t = i.enforceWhitelist ? !!this.getWhitelistItem(null === (d = this.value) || void 0 === d || null === (h = d[0]) || void 0 === h ? void 0 : h.value) : i.keepInvalidTags;
                                "select" == this.settings.mode && l && (e = ""), "select" !== this.settings.mode && e && !this.state.actions.selectOption && i.addTagOnBlur && this.addTags(e, !0), 
                                "select" != this.settings.mode || e && t || this.removeTags();
                            }
                            this.DOM.input.removeAttribute("style"), this.dropdown.hide();
                        } else "focus" == s ? this.trigger("focus", n) : "blur" == t.type && (this.trigger("blur", n), 
                        this.loading(!1), this.dropdown.hide(), this.state.dropdown.visible = void 0, this.setStateSelection());
                    },
                    onWindowKeyDown(t) {
                        var e, i = document.activeElement;
                        if (v.call(this, i) && this.DOM.scope.contains(document.activeElement)) switch (e = i.nextElementSibling, 
                        t.key) {
                          case "Backspace":
                            this.settings.readonly || (this.removeTags(i), (e || this.DOM.input).focus());
                            break;

                          case "Enter":
                            setTimeout(this.editTag.bind(this), 0, i);
                        }
                    },
                    onKeydown(t) {
                        var e = this.settings;
                        "select" == e.mode && e.enforceWhitelist && this.value.length && "Tab" != t.key && t.preventDefault();
                        var i = this.trim(t.target.textContent);
                        if (this.trigger("keydown", {
                            originalEvent: this.cloneEvent(t)
                        }), "mix" == e.mode) {
                            switch (t.key) {
                              case "Left":
                              case "ArrowLeft":
                                this.state.actions.ArrowLeft = !0;
                                break;

                              case "Delete":
                              case "Backspace":
                                if (this.state.editing) return;
                                var s, a, n, r = document.getSelection(), d = "Delete" == t.key && r.anchorOffset == (r.anchorNode.length || 0), h = r.anchorNode.previousSibling, g = 1 == r.anchorNode.nodeType || !r.anchorOffset && h && 1 == h.nodeType && r.anchorNode.previousSibling, p = o(this.DOM.input.innerHTML), c = this.getTagElms();
                                if ("edit" == e.backspace && g) return s = 1 == r.anchorNode.nodeType ? null : r.anchorNode.previousElementSibling, 
                                setTimeout(this.editTag.bind(this), 0, s), void t.preventDefault();
                                if (u() && g) return n = l(g), g.hasAttribute("readonly") || g.remove(), this.DOM.input.focus(), 
                                void setTimeout((() => {
                                    this.placeCaretAfterNode(n), this.DOM.input.click();
                                }));
                                if ("BR" == r.anchorNode.nodeName) return;
                                if ((d || g) && 1 == r.anchorNode.nodeType ? a = 0 == r.anchorOffset ? d ? c[0] : null : c[r.anchorOffset - 1] : d ? a = r.anchorNode.nextElementSibling : g && (a = g), 
                                3 == r.anchorNode.nodeType && !r.anchorNode.nodeValue && r.anchorNode.previousElementSibling && t.preventDefault(), 
                                (g || d) && !e.backspace) return void t.preventDefault();
                                if ("Range" != r.type && !r.anchorOffset && r.anchorNode == this.DOM.input && "Delete" != t.key) return void t.preventDefault();
                                if ("Range" != r.type && a && a.hasAttribute("readonly")) return void this.placeCaretAfterNode(l(a));
                                clearTimeout(y), y = setTimeout((() => {
                                    var t = document.getSelection(), e = o(this.DOM.input.innerHTML), i = !d && t.anchorNode.previousSibling;
                                    if (e.length >= p.length && i) if (v.call(this, i) && !i.hasAttribute("readonly")) {
                                        if (this.removeTags(i), this.fixFirefoxLastTagNoCaret(), 2 == this.DOM.input.children.length && "BR" == this.DOM.input.children[1].tagName) return this.DOM.input.innerHTML = "", 
                                        this.value.length = 0, !0;
                                    } else i.remove();
                                    this.value = [].map.call(c, ((t, e) => {
                                        var i = this.tagData(t);
                                        if (t.parentNode || i.readonly) return i;
                                        this.trigger("remove", {
                                            tag: t,
                                            index: e,
                                            data: i
                                        });
                                    })).filter((t => t));
                                }), 20);
                            }
                            return !0;
                        }
                        switch (t.key) {
                          case "Backspace":
                            "select" == e.mode && e.enforceWhitelist && this.value.length ? this.removeTags() : this.state.dropdown.visible && "manual" != e.dropdown.position || "" != t.target.textContent && 8203 != i.charCodeAt(0) || (!0 === e.backspace ? this.removeTags() : "edit" == e.backspace && setTimeout(this.editTag.bind(this), 0));
                            break;

                          case "Esc":
                          case "Escape":
                            if (this.state.dropdown.visible) return;
                            t.target.blur();
                            break;

                          case "Down":
                          case "ArrowDown":
                            this.state.dropdown.visible || this.dropdown.show();
                            break;

                          case "ArrowRight":
                            {
                                let t = this.state.inputSuggestion || this.state.ddItemData;
                                if (t && e.autoComplete.rightKey) return void this.addTags([ t ], !0);
                                break;
                            }

                          case "Tab":
                            {
                                let s = "select" == e.mode;
                                if (!i || s) return !0;
                                t.preventDefault();
                            }

                          case "Enter":
                            if (this.state.dropdown.visible || 229 == t.keyCode) return;
                            t.preventDefault(), setTimeout((() => {
                                this.state.actions.selectOption || this.addTags(i, !0);
                            }));
                        }
                    },
                    onInput(t) {
                        if (this.postUpdate(), "mix" == this.settings.mode) return this.events.callbacks.onMixTagsInput.call(this, t);
                        var e = this.input.normalize.call(this), i = e.length >= this.settings.dropdown.enabled, s = {
                            value: e,
                            inputElm: this.DOM.input
                        };
                        s.isValid = this.validateTag({
                            value: e
                        }), this.state.inputText != e && (this.input.set.call(this, e, !1), -1 != e.search(this.settings.delimiters) ? this.addTags(e) && this.input.set.call(this) : this.settings.dropdown.enabled >= 0 && this.dropdown[i ? "show" : "hide"](e), 
                        this.trigger("input", s));
                    },
                    onMixTagsInput(t) {
                        var e, i, s, a, n, o, r, l, d = this.settings, h = this.value.length, p = this.getTagElms(), c = document.createDocumentFragment(), m = window.getSelection().getRangeAt(0), v = [].map.call(p, (t => this.tagData(t).value));
                        if ("deleteContentBackward" == t.inputType && u() && this.events.callbacks.onKeydown.call(this, {
                            target: t.target,
                            key: "Backspace"
                        }), this.value.slice().forEach((t => {
                            t.readonly && !v.includes(t.value) && c.appendChild(this.createTagElem(t));
                        })), c.childNodes.length && (m.insertNode(c), this.setRangeAtStartEnd(!1, c.lastChild)), 
                        p.length != h) return this.value = [].map.call(this.getTagElms(), (t => this.tagData(t))), 
                        void this.update({
                            withoutChangeEvent: !0
                        });
                        if (this.hasMaxTags()) return !0;
                        if (window.getSelection && (o = window.getSelection()).rangeCount > 0 && 3 == o.anchorNode.nodeType) {
                            if ((m = o.getRangeAt(0).cloneRange()).collapse(!0), m.setStart(o.focusNode, 0), 
                            s = (e = m.toString().slice(0, m.endOffset)).split(d.pattern).length - 1, (i = e.match(d.pattern)) && (a = e.slice(e.lastIndexOf(i[i.length - 1]))), 
                            a) {
                                if (this.state.actions.ArrowLeft = !1, this.state.tag = {
                                    prefix: a.match(d.pattern)[0],
                                    value: a.replace(d.pattern, "")
                                }, this.state.tag.baseOffset = o.baseOffset - this.state.tag.value.length, l = this.state.tag.value.match(d.delimiters)) return this.state.tag.value = this.state.tag.value.replace(d.delimiters, ""), 
                                this.state.tag.delimiters = l[0], this.addTags(this.state.tag.value, d.dropdown.clearOnSelect), 
                                void this.dropdown.hide();
                                n = this.state.tag.value.length >= d.dropdown.enabled;
                                try {
                                    r = (r = this.state.flaggedTags[this.state.tag.baseOffset]).prefix == this.state.tag.prefix && r.value[0] == this.state.tag.value[0], 
                                    this.state.flaggedTags[this.state.tag.baseOffset] && !this.state.tag.value && delete this.state.flaggedTags[this.state.tag.baseOffset];
                                } catch (t) {}
                                (r || s < this.state.mixMode.matchedPatternCount) && (n = !1);
                            } else this.state.flaggedTags = {};
                            this.state.mixMode.matchedPatternCount = s;
                        }
                        setTimeout((() => {
                            this.update({
                                withoutChangeEvent: !0
                            }), this.trigger("input", g({}, this.state.tag, {
                                textContent: this.DOM.input.textContent
                            })), this.state.tag && this.dropdown[n ? "show" : "hide"](this.state.tag.value);
                        }), 10);
                    },
                    onInputIE(t) {
                        var e = this;
                        setTimeout((function() {
                            e.events.callbacks.onInput.call(e, t);
                        }));
                    },
                    observeOriginalInputValue() {
                        this.DOM.originalInput.value != this.DOM.originalInput.tagifyValue && this.loadOriginalValues();
                    },
                    onClickScope(t) {
                        var e = this.settings, i = t.target.closest("." + e.classNames.tag), s = +new Date - this.state.hasFocus;
                        if (t.target != this.DOM.scope) {
                            if (!t.target.classList.contains(e.classNames.tagX)) return i ? (this.trigger("click", {
                                tag: i,
                                index: this.getNodeIndex(i),
                                data: this.tagData(i),
                                originalEvent: this.cloneEvent(t)
                            }), void (1 !== e.editTags && 1 !== e.editTags.clicks || this.events.callbacks.onDoubleClickScope.call(this, t))) : void (t.target == this.DOM.input && ("mix" == e.mode && this.fixFirefoxLastTagNoCaret(), 
                            s > 500) ? this.state.dropdown.visible ? this.dropdown.hide() : 0 === e.dropdown.enabled && "mix" != e.mode && this.dropdown.show(this.value.length ? "" : void 0) : "select" == e.mode && !this.state.dropdown.visible && this.dropdown.show());
                            this.removeTags(t.target.parentNode);
                        } else this.state.hasFocus || this.DOM.input.focus();
                    },
                    onPaste(t) {
                        t.preventDefault();
                        var e, i, s = this.settings;
                        if ("select" == s.mode && s.enforceWhitelist || !s.userInput) return !1;
                        s.readonly || (e = t.clipboardData || window.clipboardData, i = e.getData("Text"), 
                        s.hooks.beforePaste(t, {
                            tagify: this,
                            pastedText: i,
                            clipboardData: e
                        }).then((e => {
                            void 0 === e && (e = i), e && (this.injectAtCaret(e, window.getSelection().getRangeAt(0)), 
                            "mix" == this.settings.mode ? this.events.callbacks.onMixTagsInput.call(this, t) : this.settings.pasteAsTags ? this.addTags(this.state.inputText + e, !0) : this.state.inputText = e);
                        })).catch((t => t)));
                    },
                    onDrop(t) {
                        t.preventDefault();
                    },
                    onEditTagInput(t, e) {
                        var i = t.closest("." + this.settings.classNames.tag), s = this.getNodeIndex(i), a = this.tagData(i), n = this.input.normalize.call(this, t), o = i.innerHTML != i.__tagifyTagData.__originalHTML, r = this.validateTag(g(i.__tagifyTagData, {
                            [this.settings.tagTextProp]: n
                        }));
                        o || !0 !== t.originalIsValid || (r = !0), i.classList.toggle(this.settings.classNames.tagInvalid, !0 !== r), 
                        a.__isValid = r, i.title = !0 === r ? a.title || a.value : r, n.length >= this.settings.dropdown.enabled && (this.state.editing && (this.state.editing.value = n), 
                        this.dropdown.show(n)), this.trigger("edit:input", {
                            tag: i,
                            index: s,
                            data: g({}, this.value[s], {
                                newValue: n
                            }),
                            originalEvent: this.cloneEvent(e)
                        });
                    },
                    onEditTagFocus(t) {
                        this.state.editing = {
                            scope: t,
                            input: t.querySelector("[contenteditable]")
                        };
                    },
                    onEditTagBlur(t) {
                        if (this.state.hasFocus || this.toggleFocusClass(), this.DOM.scope.contains(t)) {
                            var e, i, s = this.settings, a = t.closest("." + s.classNames.tag), n = this.input.normalize.call(this, t), o = this.tagData(a).__originalData, r = a.innerHTML != a.__tagifyTagData.__originalHTML, l = this.validateTag({
                                [s.tagTextProp]: n
                            });
                            if (n) if (r) {
                                if (e = this.hasMaxTags(), i = g({}, o, {
                                    [s.tagTextProp]: this.trim(n),
                                    value: n,
                                    __isValid: l
                                }), s.transformTag.call(this, i, o), !0 !== (l = (!e || !0 === o.__isValid) && this.validateTag(i))) {
                                    if (this.trigger("invalid", {
                                        data: i,
                                        tag: a,
                                        message: l
                                    }), s.editTags.keepInvalid) return;
                                    s.keepInvalidTags ? i.__isValid = l : i = o;
                                } else s.keepInvalidTags && (delete i.title, delete i["aria-invalid"], delete i.class);
                                this.onEditTagDone(a, i);
                            } else this.onEditTagDone(a, o); else this.onEditTagDone(a);
                        }
                    },
                    onEditTagkeydown(t, e) {
                        switch (this.trigger("edit:keydown", {
                            originalEvent: this.cloneEvent(t)
                        }), t.key) {
                          case "Esc":
                          case "Escape":
                            e.innerHTML = e.__tagifyTagData.__originalHTML;

                          case "Enter":
                          case "Tab":
                            t.preventDefault(), t.target.blur();
                        }
                    },
                    onDoubleClickScope(t) {
                        var e, i, s = t.target.closest("." + this.settings.classNames.tag), a = this.settings;
                        s && a.userInput && (e = s.classList.contains(this.settings.classNames.tagEditing), 
                        i = s.hasAttribute("readonly"), "select" == a.mode || a.readonly || e || i || !this.settings.editTags || this.editTag(s), 
                        this.toggleFocusClass(!0), this.trigger("dblclick", {
                            tag: s,
                            index: this.getNodeIndex(s),
                            data: this.tagData(s)
                        }));
                    },
                    onInputDOMChange(t) {
                        t.forEach((t => {
                            t.addedNodes.forEach((t => {
                                if (t) if ("<div><br></div>" == t.outerHTML) t.replaceWith(document.createElement("br")); else if (1 == t.nodeType && t.querySelector(this.settings.classNames.tagSelector)) {
                                    let e = document.createTextNode("");
                                    3 == t.childNodes[0].nodeType && "BR" != t.previousSibling.nodeName && (e = document.createTextNode("\n")), 
                                    t.replaceWith(e, ...[ ...t.childNodes ].slice(0, -1)), this.placeCaretAfterNode(e.previousSibling);
                                } else v.call(this, t) && t.previousSibling && "BR" == t.previousSibling.nodeName && (t.previousSibling.replaceWith("\n​"), 
                                this.placeCaretAfterNode(t.previousSibling.previousSibling));
                            })), t.removedNodes.forEach((t => {
                                t && "BR" == t.nodeName && v.call(this, e) && (this.removeTags(e), this.fixFirefoxLastTagNoCaret());
                            }));
                        }));
                        var e = this.DOM.input.lastChild;
                        e && "" == e.nodeValue && e.remove(), e && "BR" == e.nodeName || this.DOM.input.appendChild(document.createElement("br"));
                    }
                }
            };
            function M(t, e) {
                if (!t) {
                    console.warn("Tagify:", "input element not found", t);
                    const e = new Proxy(this, {
                        get: () => () => e
                    });
                    return e;
                }
                if (t.previousElementSibling && t.previousElementSibling.classList.contains("tagify")) return console.warn("Tagify: ", "input element is already Tagified", t), 
                this;
                var i;
                g(this, function(t) {
                    var e = document.createTextNode("");
                    function i(t, i, s) {
                        s && i.split(/\s+/g).forEach((i => e[t + "EventListener"].call(e, i, s)));
                    }
                    return {
                        off(t, e) {
                            return i("remove", t, e), this;
                        },
                        on(t, e) {
                            return e && "function" == typeof e && i("add", t, e), this;
                        },
                        trigger(i, s, a) {
                            var n;
                            if (a = a || {
                                cloneData: !0
                            }, i) if (t.settings.isJQueryPlugin) "remove" == i && (i = "removeTag"), jQuery(t.DOM.originalInput).triggerHandler(i, [ s ]); else {
                                try {
                                    var o = "object" == typeof s ? s : {
                                        value: s
                                    };
                                    if ((o = a.cloneData ? g({}, o) : o).tagify = this, s instanceof Object) for (var r in s) s[r] instanceof HTMLElement && (o[r] = s[r]);
                                    n = new CustomEvent(i, {
                                        detail: o
                                    });
                                } catch (t) {
                                    console.warn(t);
                                }
                                e.dispatchEvent(n);
                            }
                        }
                    };
                }(this)), this.isFirefox = "undefined" != typeof InstallTrigger, this.isIE = window.document.documentMode, 
                e = e || {}, this.getPersistedData = (i = e.id, t => {
                    let e, s = "/" + t;
                    if (1 == localStorage.getItem(b + i + "/v", 1)) try {
                        e = JSON.parse(localStorage[b + i + s]);
                    } catch (t) {}
                    return e;
                }), this.setPersistedData = (t => t ? (localStorage.setItem(b + t + "/v", 1), (e, i) => {
                    let s = "/" + i, a = JSON.stringify(e);
                    e && i && (localStorage.setItem(b + t + s, a), dispatchEvent(new Event("storage")));
                }) : () => {})(e.id), this.clearPersistedData = (t => e => {
                    const i = b + "/" + t + "/";
                    if (e) localStorage.removeItem(i + e); else for (let t in localStorage) t.includes(i) && localStorage.removeItem(t);
                })(e.id), this.applySettings(t, e), this.state = {
                    inputText: "",
                    editing: !1,
                    actions: {},
                    mixMode: {},
                    dropdown: {},
                    flaggedTags: {}
                }, this.value = [], this.listeners = {}, this.DOM = {}, this.build(t), T.call(this), 
                this.getCSSVars(), this.loadOriginalValues(), this.events.customBinding.call(this), 
                this.events.binding.call(this), t.autofocus && this.DOM.input.focus();
            }
            return M.prototype = {
                _dropdown: w,
                helpers: {
                    sameStr: s,
                    removeCollectionProp: a,
                    omit: n,
                    isObject: h,
                    parseHTML: r,
                    escapeHTML: d,
                    extend: g,
                    concatWithoutDups: p,
                    getUID: m,
                    isNodeTag: v
                },
                customEventsList: [ "change", "add", "remove", "invalid", "input", "click", "keydown", "focus", "blur", "edit:input", "edit:beforeUpdate", "edit:updated", "edit:start", "edit:keydown", "dropdown:show", "dropdown:hide", "dropdown:select", "dropdown:updated", "dropdown:noMatch", "dropdown:scroll" ],
                dataProps: [ "__isValid", "__removed", "__originalData", "__originalHTML", "__tagId" ],
                trim(t) {
                    return this.settings.trim && t && "string" == typeof t ? t.trim() : t;
                },
                parseHTML: r,
                templates: D,
                parseTemplate(t, e) {
                    return t = this.settings.templates[t] || t, this.parseHTML(t.apply(this, e));
                },
                set whitelist(t) {
                    const e = t && Array.isArray(t);
                    this.settings.whitelist = e ? t : [], this.setPersistedData(e ? t : [], "whitelist");
                },
                get whitelist() {
                    return this.settings.whitelist;
                },
                applySettings(t, i) {
                    f.templates = this.templates;
                    var s = this.settings = g({}, f, i);
                    s.disabled = t.hasAttribute("disabled"), s.readonly = s.readonly || t.hasAttribute("readonly"), 
                    s.placeholder = d(t.getAttribute("placeholder") || s.placeholder || ""), s.required = t.hasAttribute("required");
                    for (let t in s.classNames) Object.defineProperty(s.classNames, t + "Selector", {
                        get() {
                            return "." + this[t].split(" ")[0];
                        }
                    });
                    if (this.isIE && (s.autoComplete = !1), [ "whitelist", "blacklist" ].forEach((e => {
                        var i = t.getAttribute("data-" + e);
                        i && (i = i.split(s.delimiters)) instanceof Array && (s[e] = i);
                    })), "autoComplete" in i && !h(i.autoComplete) && (s.autoComplete = f.autoComplete, 
                    s.autoComplete.enabled = i.autoComplete), "mix" == s.mode && (s.autoComplete.rightKey = !0, 
                    s.delimiters = i.delimiters || null, s.tagTextProp && !s.dropdown.searchKeys.includes(s.tagTextProp) && s.dropdown.searchKeys.push(s.tagTextProp)), 
                    t.pattern) try {
                        s.pattern = new RegExp(t.pattern);
                    } catch (t) {}
                    if (this.settings.delimiters) try {
                        s.delimiters = new RegExp(this.settings.delimiters, "g");
                    } catch (t) {}
                    s.disabled && (s.userInput = !1), this.TEXTS = e(e({}, x), s.texts || {}), "select" != s.mode && s.userInput || (s.dropdown.enabled = 0), 
                    s.dropdown.appendTarget = i.dropdown && i.dropdown.appendTarget ? i.dropdown.appendTarget : document.body;
                    let a = this.getPersistedData("whitelist");
                    Array.isArray(a) && (this.whitelist = Array.isArray(s.whitelist) ? p(s.whitelist, a) : a);
                },
                getAttributes(t) {
                    var e, i = this.getCustomAttributes(t), s = "";
                    for (e in i) s += " " + e + (void 0 !== t[e] ? `="${i[e]}"` : "");
                    return s;
                },
                getCustomAttributes(t) {
                    if (!h(t)) return "";
                    var e, i = {};
                    for (e in t) "__" != e.slice(0, 2) && "class" != e && t.hasOwnProperty(e) && void 0 !== t[e] && (i[e] = d(t[e]));
                    return i;
                },
                setStateSelection() {
                    var t = window.getSelection(), e = {
                        anchorOffset: t.anchorOffset,
                        anchorNode: t.anchorNode,
                        range: t.getRangeAt && t.rangeCount && t.getRangeAt(0)
                    };
                    return this.state.selection = e, e;
                },
                getCaretGlobalPosition() {
                    const t = document.getSelection();
                    if (t.rangeCount) {
                        const e = t.getRangeAt(0), i = e.startContainer, s = e.startOffset;
                        let a, n;
                        if (s > 0) return n = document.createRange(), n.setStart(i, s - 1), n.setEnd(i, s), 
                        a = n.getBoundingClientRect(), {
                            left: a.right,
                            top: a.top,
                            bottom: a.bottom
                        };
                        if (i.getBoundingClientRect) return i.getBoundingClientRect();
                    }
                    return {
                        left: -9999,
                        top: -9999
                    };
                },
                getCSSVars() {
                    var t = getComputedStyle(this.DOM.scope, null);
                    var e;
                    this.CSSVars = {
                        tagHideTransition: (({value: t, unit: e}) => "s" == e ? 1e3 * t : t)(function(t) {
                            if (!t) return {};
                            var e = (t = t.trim().split(" ")[0]).split(/\d+/g).filter((t => t)).pop().trim();
                            return {
                                value: +t.split(e).filter((t => t))[0].trim(),
                                unit: e
                            };
                        }((e = "tag-hide-transition", t.getPropertyValue("--" + e))))
                    };
                },
                build(t) {
                    var e = this.DOM;
                    this.settings.mixMode.integrated ? (e.originalInput = null, e.scope = t, e.input = t) : (e.originalInput = t, 
                    e.originalInput_tabIndex = t.tabIndex, e.scope = this.parseTemplate("wrapper", [ t, this.settings ]), 
                    e.input = e.scope.querySelector(this.settings.classNames.inputSelector), t.parentNode.insertBefore(e.scope, t), 
                    t.tabIndex = -1);
                },
                destroy() {
                    this.events.unbindGlobal.call(this), this.DOM.scope.parentNode.removeChild(this.DOM.scope), 
                    this.DOM.originalInput.tabIndex = this.DOM.originalInput_tabIndex, this.dropdown.hide(!0), 
                    clearTimeout(this.dropdownHide__bindEventsTimeout);
                },
                loadOriginalValues(t) {
                    var e, i = this.settings;
                    if (this.state.blockChangeEvent = !0, void 0 === t) {
                        const e = this.getPersistedData("value");
                        t = e && !this.DOM.originalInput.value ? e : i.mixMode.integrated ? this.DOM.input.textContent : this.DOM.originalInput.value;
                    }
                    if (this.removeAllTags(), t) if ("mix" == i.mode) this.parseMixTags(this.trim(t)), 
                    (e = this.DOM.input.lastChild) && "BR" == e.tagName || this.DOM.input.insertAdjacentHTML("beforeend", "<br>"); else {
                        try {
                            JSON.parse(t) instanceof Array && (t = JSON.parse(t));
                        } catch (t) {}
                        this.addTags(t).forEach((t => t && t.classList.add(i.classNames.tagNoAnimation)));
                    } else this.postUpdate();
                    this.state.lastOriginalValueReported = i.mixMode.integrated ? "" : this.DOM.originalInput.value, 
                    this.state.blockChangeEvent = !1;
                },
                cloneEvent(t) {
                    var e = {};
                    for (var i in t) e[i] = t[i];
                    return e;
                },
                loading(t) {
                    return this.state.isLoading = t, this.DOM.scope.classList[t ? "add" : "remove"](this.settings.classNames.scopeLoading), 
                    this;
                },
                tagLoading(t, e) {
                    return t && t.classList[e ? "add" : "remove"](this.settings.classNames.tagLoading), 
                    this;
                },
                toggleClass(t, e) {
                    "string" == typeof t && this.DOM.scope.classList.toggle(t, e);
                },
                toggleFocusClass(t) {
                    this.toggleClass(this.settings.classNames.focus, !!t);
                },
                triggerChangeEvent: function() {
                    if (!this.settings.mixMode.integrated) {
                        var t = this.DOM.originalInput, e = this.state.lastOriginalValueReported !== t.value, i = new CustomEvent("change", {
                            bubbles: !0
                        });
                        e && (this.state.lastOriginalValueReported = t.value, i.simulated = !0, t._valueTracker && t._valueTracker.setValue(Math.random()), 
                        t.dispatchEvent(i), this.trigger("change", this.state.lastOriginalValueReported), 
                        t.value = this.state.lastOriginalValueReported);
                    }
                },
                events: O,
                fixFirefoxLastTagNoCaret() {},
                placeCaretAfterNode(t) {
                    if (t && t.parentNode) {
                        var e = t.nextSibling, i = window.getSelection(), s = i.getRangeAt(0);
                        i.rangeCount && (s.setStartAfter(e || t), s.collapse(!0), i.removeAllRanges(), i.addRange(s));
                    }
                },
                insertAfterTag(t, e) {
                    if (e = e || this.settings.mixMode.insertAfterTag, t && t.parentNode && e) return e = "string" == typeof e ? document.createTextNode(e) : e, 
                    t.parentNode.insertBefore(e, t.nextSibling), e;
                },
                editTag(t, e) {
                    t = t || this.getLastTag(), e = e || {}, this.dropdown.hide();
                    var i = this.settings;
                    function s() {
                        return t.querySelector(i.classNames.tagTextSelector);
                    }
                    var a = s(), n = this.getNodeIndex(t), o = this.tagData(t), r = this.events.callbacks, l = this, d = !0;
                    if (a) {
                        if (!(o instanceof Object && "editable" in o) || o.editable) return a.setAttribute("contenteditable", !0), 
                        t.classList.add(i.classNames.tagEditing), this.tagData(t, {
                            __originalData: g({}, o),
                            __originalHTML: t.innerHTML
                        }), a.addEventListener("focus", r.onEditTagFocus.bind(this, t)), a.addEventListener("blur", (function() {
                            setTimeout((() => r.onEditTagBlur.call(l, s())));
                        })), a.addEventListener("input", r.onEditTagInput.bind(this, a)), a.addEventListener("keydown", (e => r.onEditTagkeydown.call(this, e, t))), 
                        a.focus(), this.setRangeAtStartEnd(!1, a), e.skipValidation || (d = this.editTagToggleValidity(t)), 
                        a.originalIsValid = d, this.trigger("edit:start", {
                            tag: t,
                            index: n,
                            data: o,
                            isValid: d
                        }), this;
                    } else console.warn("Cannot find element in Tag template: .", i.classNames.tagTextSelector);
                },
                editTagToggleValidity(t, e) {
                    var i;
                    if (e = e || this.tagData(t)) return (i = !("__isValid" in e) || !0 === e.__isValid) || this.removeTagsFromValue(t), 
                    this.update(), t.classList.toggle(this.settings.classNames.tagNotAllowed, !i), e.__isValid;
                    console.warn("tag has no data: ", t, e);
                },
                onEditTagDone(t, e) {
                    e = e || {};
                    var i = {
                        tag: t = t || this.state.editing.scope,
                        index: this.getNodeIndex(t),
                        previousData: this.tagData(t),
                        data: e
                    };
                    this.trigger("edit:beforeUpdate", i, {
                        cloneData: !1
                    }), this.state.editing = !1, delete e.__originalData, delete e.__originalHTML, t && e[this.settings.tagTextProp] ? (t = this.replaceTag(t, e), 
                    this.editTagToggleValidity(t, e), this.settings.a11y.focusableTags ? t.focus() : this.placeCaretAfterNode(t.previousSibling)) : t && this.removeTags(t), 
                    this.trigger("edit:updated", i), this.dropdown.hide(), this.settings.keepInvalidTags && this.reCheckInvalidTags();
                },
                replaceTag(t, e) {
                    e && e.value || (e = t.__tagifyTagData), e.__isValid && 1 != e.__isValid && g(e, this.getInvalidTagAttrs(e, e.__isValid));
                    var i = this.createTagElem(e);
                    return t.parentNode.replaceChild(i, t), this.updateValueByDOMTags(), i;
                },
                updateValueByDOMTags() {
                    this.value.length = 0, [].forEach.call(this.getTagElms(), (t => {
                        t.classList.contains(this.settings.classNames.tagNotAllowed.split(" ")[0]) || this.value.push(this.tagData(t));
                    })), this.update();
                },
                setRangeAtStartEnd(t, e) {
                    t = "number" == typeof t ? t : !!t, e = (e = e || this.DOM.input).lastChild || e;
                    var i = document.getSelection();
                    try {
                        i.rangeCount >= 1 && [ "Start", "End" ].forEach((s => i.getRangeAt(0)["set" + s](e, t || e.length)));
                    } catch (t) {}
                },
                injectAtCaret(t, e) {
                    if (e = e || this.state.selection.range) return "string" == typeof t && (t = document.createTextNode(t)), 
                    e.deleteContents(), e.insertNode(t), this.setRangeAtStartEnd(!1, t), this.updateValueByDOMTags(), 
                    this.update(), this;
                },
                input: {
                    set(t = "", e = !0) {
                        var i = this.settings.dropdown.closeOnSelect;
                        this.state.inputText = t, e && (this.DOM.input.innerHTML = d("" + t)), !t && i && this.dropdown.hide.bind(this), 
                        this.input.autocomplete.suggest.call(this), this.input.validate.call(this);
                    },
                    raw() {
                        return this.DOM.input.textContent;
                    },
                    validate() {
                        var t = !this.state.inputText || !0 === this.validateTag({
                            value: this.state.inputText
                        });
                        return this.DOM.input.classList.toggle(this.settings.classNames.inputInvalid, !t), 
                        t;
                    },
                    normalize(t) {
                        var e = t || this.DOM.input, i = [];
                        e.childNodes.forEach((t => 3 == t.nodeType && i.push(t.nodeValue))), i = i.join("\n");
                        try {
                            i = i.replace(/(?:\r\n|\r|\n)/g, this.settings.delimiters.source.charAt(0));
                        } catch (t) {}
                        return i = i.replace(/\s/g, " "), this.settings.trim && (i = i.replace(/^\s+/, "")), 
                        this.trim(i);
                    },
                    autocomplete: {
                        suggest(t) {
                            if (this.settings.autoComplete.enabled) {
                                "string" == typeof (t = t || {}) && (t = {
                                    value: t
                                });
                                var e = t.value ? "" + t.value : "", i = e.substr(0, this.state.inputText.length).toLowerCase(), s = e.substring(this.state.inputText.length);
                                e && this.state.inputText && i == this.state.inputText.toLowerCase() ? (this.DOM.input.setAttribute("data-suggest", s), 
                                this.state.inputSuggestion = t) : (this.DOM.input.removeAttribute("data-suggest"), 
                                delete this.state.inputSuggestion);
                            }
                        },
                        set(t) {
                            var e = this.DOM.input.getAttribute("data-suggest"), i = t || (e ? this.state.inputText + e : null);
                            return !!i && ("mix" == this.settings.mode ? this.replaceTextWithNode(document.createTextNode(this.state.tag.prefix + i)) : (this.input.set.call(this, i), 
                            this.setRangeAtStartEnd()), this.input.autocomplete.suggest.call(this), this.dropdown.hide(), 
                            !0);
                        }
                    }
                },
                getTagIdx(t) {
                    return this.value.findIndex((e => e.__tagId == (t || {}).__tagId));
                },
                getNodeIndex(t) {
                    var e = 0;
                    if (t) for (;t = t.previousElementSibling; ) e++;
                    return e;
                },
                getTagElms(...t) {
                    var e = "." + [ ...this.settings.classNames.tag.split(" "), ...t ].join(".");
                    return [].slice.call(this.DOM.scope.querySelectorAll(e));
                },
                getLastTag() {
                    var t = this.DOM.scope.querySelectorAll(`${this.settings.classNames.tagSelector}:not(.${this.settings.classNames.tagHide}):not([readonly])`);
                    return t[t.length - 1];
                },
                tagData: (t, e, i) => t ? (e && (t.__tagifyTagData = i ? e : g({}, t.__tagifyTagData || {}, e)), 
                t.__tagifyTagData) : (console.warn("tag element doesn't exist", t, e), e),
                isTagDuplicate(t, e, i) {
                    var a = this.settings;
                    return "select" != a.mode && this.value.reduce(((n, o) => s(this.trim("" + t), o.value, e || a.dropdown.caseSensitive) && i != o.__tagId ? n + 1 : n), 0);
                },
                getTagIndexByValue(t) {
                    var e = [];
                    return this.getTagElms().forEach(((i, a) => {
                        s(this.trim(i.textContent), t, this.settings.dropdown.caseSensitive) && e.push(a);
                    })), e;
                },
                getTagElmByValue(t) {
                    var e = this.getTagIndexByValue(t)[0];
                    return this.getTagElms()[e];
                },
                flashTag(t) {
                    t && (t.classList.add(this.settings.classNames.tagFlash), setTimeout((() => {
                        t.classList.remove(this.settings.classNames.tagFlash);
                    }), 100));
                },
                isTagBlacklisted(t) {
                    return t = this.trim(t.toLowerCase()), this.settings.blacklist.filter((e => ("" + e).toLowerCase() == t)).length;
                },
                isTagWhitelisted(t) {
                    return !!this.getWhitelistItem(t);
                },
                getWhitelistItem(t, e, i) {
                    e = e || "value";
                    var a, n = this.settings;
                    return (i = i || n.whitelist).some((i => {
                        var o = "string" == typeof i ? i : i[e] || i.value;
                        if (s(o, t, n.dropdown.caseSensitive, n.trim)) return a = "string" == typeof i ? {
                            value: i
                        } : i, !0;
                    })), a || "value" != e || "value" == n.tagTextProp || (a = this.getWhitelistItem(t, n.tagTextProp, i)), 
                    a;
                },
                validateTag(t) {
                    var e = this.settings, i = "value" in t ? "value" : e.tagTextProp, s = this.trim(t[i] + "");
                    return (t[i] + "").trim() ? e.pattern && e.pattern instanceof RegExp && !e.pattern.test(s) ? this.TEXTS.pattern : !e.duplicates && this.isTagDuplicate(s, this.state.editing, t.__tagId) ? this.TEXTS.duplicate : this.isTagBlacklisted(s) || e.enforceWhitelist && !this.isTagWhitelisted(s) ? this.TEXTS.notAllowed : !e.validate || e.validate(t) : this.TEXTS.empty;
                },
                getInvalidTagAttrs(t, e) {
                    return {
                        "aria-invalid": !0,
                        class: `${t.class || ""} ${this.settings.classNames.tagNotAllowed}`.trim(),
                        title: e
                    };
                },
                hasMaxTags() {
                    return this.value.length >= this.settings.maxTags && this.TEXTS.exceed;
                },
                setReadonly(t, e) {
                    var i = this.settings;
                    document.activeElement.blur(), i[e || "readonly"] = t, this.DOM.scope[(t ? "set" : "remove") + "Attribute"](e || "readonly", !0), 
                    this.setContentEditable(!t);
                },
                setContentEditable(t) {
                    !this.settings.readonly && this.settings.userInput && (this.DOM.input.contentEditable = t, 
                    this.DOM.input.tabIndex = t ? 0 : -1);
                },
                setDisabled(t) {
                    this.setReadonly(t, "disabled");
                },
                normalizeTags(t) {
                    var e = this.settings, i = e.whitelist, s = e.delimiters, a = e.mode, n = e.tagTextProp;
                    e.enforceWhitelist;
                    var o = [], r = !!i && i[0] instanceof Object, l = t instanceof Array, d = t => (t + "").split(s).filter((t => t)).map((t => ({
                        [n]: this.trim(t),
                        value: this.trim(t)
                    })));
                    if ("number" == typeof t && (t = t.toString()), "string" == typeof t) {
                        if (!t.trim()) return [];
                        t = d(t);
                    } else l && (t = [].concat(...t.map((t => t.value ? t : d(t)))));
                    return r && (t.forEach((t => {
                        var e = o.map((t => t.value)), i = this.dropdown.filterListItems.call(this, t[n], {
                            exact: !0
                        });
                        this.settings.duplicates || (i = i.filter((t => !e.includes(t.value))));
                        var s = i.length > 1 ? this.getWhitelistItem(t[n], n, i) : i[0];
                        s && s instanceof Object ? o.push(s) : "mix" != a && (null == t.value && (t.value = t[n]), 
                        o.push(t));
                    })), o.length && (t = o)), t;
                },
                parseMixTags(t) {
                    var e = this.settings, i = e.mixTagsInterpolator, s = e.duplicates, a = e.transformTag, n = e.enforceWhitelist, o = e.maxTags, r = e.tagTextProp, l = [];
                    return t = t.split(i[0]).map(((t, e) => {
                        var d, h, g, p = t.split(i[1]), c = p[0], u = l.length == o;
                        try {
                            if (c == +c) throw Error;
                            h = JSON.parse(c);
                        } catch (t) {
                            h = this.normalizeTags(c)[0] || {
                                value: c
                            };
                        }
                        if (a.call(this, h), u || !(p.length > 1) || n && !this.isTagWhitelisted(h.value) || !s && this.isTagDuplicate(h.value)) {
                            if (t) return e ? i[0] + t : t;
                        } else h[d = h[r] ? r : "value"] = this.trim(h[d]), g = this.createTagElem(h), l.push(h), 
                        g.classList.add(this.settings.classNames.tagNoAnimation), p[0] = g.outerHTML, this.value.push(h);
                        return p.join("");
                    })).join(""), this.DOM.input.innerHTML = t, this.DOM.input.appendChild(document.createTextNode("")), 
                    this.DOM.input.normalize(), this.getTagElms().forEach(((t, e) => this.tagData(t, l[e]))), 
                    this.update({
                        withoutChangeEvent: !0
                    }), t;
                },
                replaceTextWithNode(t, e) {
                    if (this.state.tag || e) {
                        e = e || this.state.tag.prefix + this.state.tag.value;
                        var i, s, a = window.getSelection(), n = a.anchorNode, o = this.state.tag.delimiters ? this.state.tag.delimiters.length : 0;
                        return n.splitText(a.anchorOffset - o), -1 == (i = n.nodeValue.lastIndexOf(e)) ? !0 : (s = n.splitText(i), 
                        t && n.parentNode.replaceChild(t, s), !0);
                    }
                },
                selectTag(t, e) {
                    var i = this.settings;
                    if (!i.enforceWhitelist || this.isTagWhitelisted(e.value)) {
                        this.input.set.call(this, e[i.tagTextProp] || e.value, !0), this.state.actions.selectOption && setTimeout(this.setRangeAtStartEnd.bind(this));
                        var s = this.getLastTag();
                        return s ? this.replaceTag(s, e) : this.appendTag(t), this.value[0] = e, this.update(), 
                        this.trigger("add", {
                            tag: t,
                            data: e
                        }), [ t ];
                    }
                },
                addEmptyTag(t) {
                    var e = g({
                        value: ""
                    }, t || {}), i = this.createTagElem(e);
                    this.tagData(i, e), this.appendTag(i), this.editTag(i, {
                        skipValidation: !0
                    });
                },
                addTags(t, e, i) {
                    var s = [], a = this.settings, n = document.createDocumentFragment();
                    return i = i || a.skipInvalid, t && 0 != t.length ? (t = this.normalizeTags(t), 
                    "mix" == a.mode ? this.addMixTags(t) : ("select" == a.mode && (e = !1), this.DOM.input.removeAttribute("style"), 
                    t.forEach((t => {
                        var e, o = {}, r = Object.assign({}, t, {
                            value: t.value + ""
                        });
                        if (t = Object.assign({}, r), a.transformTag.call(this, t), t.__isValid = this.hasMaxTags() || this.validateTag(t), 
                        !0 !== t.__isValid) {
                            if (i) return;
                            g(o, this.getInvalidTagAttrs(t, t.__isValid), {
                                __preInvalidData: r
                            }), t.__isValid == this.TEXTS.duplicate && this.flashTag(this.getTagElmByValue(t.value));
                        }
                        if ("readonly" in t && (t.readonly ? o["aria-readonly"] = !0 : delete t.readonly), 
                        e = this.createTagElem(t, o), s.push(e), "select" == a.mode) return this.selectTag(e, t);
                        n.appendChild(e), t.__isValid && !0 === t.__isValid ? (this.value.push(t), this.trigger("add", {
                            tag: e,
                            index: this.value.length - 1,
                            data: t
                        })) : (this.trigger("invalid", {
                            data: t,
                            index: this.value.length,
                            tag: e,
                            message: t.__isValid
                        }), a.keepInvalidTags || setTimeout((() => this.removeTags(e, !0)), 1e3)), this.dropdown.position();
                    })), this.appendTag(n), this.update(), t.length && e && this.input.set.call(this), 
                    this.dropdown.refilter(), s)) : ("select" == a.mode && this.removeAllTags(), s);
                },
                addMixTags(t) {
                    if ((t = this.normalizeTags(t))[0].prefix || this.state.tag) return this.prefixedTextToTag(t[0]);
                    "string" == typeof t && (t = [ {
                        value: t
                    } ]);
                    var e = !!this.state.selection, i = document.createDocumentFragment();
                    return t.forEach((t => {
                        var e = this.createTagElem(t);
                        i.appendChild(e), this.insertAfterTag(e);
                    })), e ? this.injectAtCaret(i) : (this.DOM.input.focus(), (e = this.setStateSelection()).range.setStart(this.DOM.input, e.range.endOffset), 
                    e.range.setEnd(this.DOM.input, e.range.endOffset), this.DOM.input.appendChild(i), 
                    this.updateValueByDOMTags(), this.update()), i;
                },
                prefixedTextToTag(t) {
                    var e, i = this.settings, s = this.state.tag.delimiters;
                    if (i.transformTag.call(this, t), t.prefix = t.prefix || this.state.tag ? this.state.tag.prefix : (i.pattern.source || i.pattern)[0], 
                    e = this.createTagElem(t), this.replaceTextWithNode(e) || this.DOM.input.appendChild(e), 
                    setTimeout((() => e.classList.add(this.settings.classNames.tagNoAnimation)), 300), 
                    this.value.push(t), this.update(), !s) {
                        var a = this.insertAfterTag(e) || e;
                        this.placeCaretAfterNode(a);
                    }
                    return this.state.tag = null, this.trigger("add", g({}, {
                        tag: e
                    }, {
                        data: t
                    })), e;
                },
                appendTag(t) {
                    var e = this.DOM, i = e.input;
                    i === e.input ? e.scope.insertBefore(t, i) : e.scope.appendChild(t);
                },
                createTagElem(t, i) {
                    t.__tagId = m();
                    var s, a = g({}, t, e({
                        value: d(t.value + "")
                    }, i));
                    return function(t) {
                        for (var e, i = document.createNodeIterator(t, NodeFilter.SHOW_TEXT, null, !1); e = i.nextNode(); ) e.textContent.trim() || e.parentNode.removeChild(e);
                    }(s = this.parseTemplate("tag", [ a ])), this.tagData(s, t), s;
                },
                reCheckInvalidTags() {
                    var t = this.settings;
                    this.getTagElms(t.classNames.tagNotAllowed).forEach(((t, e) => {
                        var i = this.tagData(t), s = this.hasMaxTags(), a = this.validateTag(i);
                        if (!0 === a && !s) return i = i.__preInvalidData ? i.__preInvalidData : {
                            value: i.value
                        }, this.replaceTag(t, i);
                        t.title = s || a;
                    }));
                },
                removeTags(t, e, i) {
                    var s;
                    if (t = t && t instanceof HTMLElement ? [ t ] : t instanceof Array ? t : t ? [ t ] : [ this.getLastTag() ], 
                    s = t.reduce(((t, e) => {
                        e && "string" == typeof e && (e = this.getTagElmByValue(e));
                        var i = this.tagData(e);
                        return e && i && !i.readonly && t.push({
                            node: e,
                            idx: this.getTagIdx(i),
                            data: this.tagData(e, {
                                __removed: !0
                            })
                        }), t;
                    }), []), i = "number" == typeof i ? i : this.CSSVars.tagHideTransition, "select" == this.settings.mode && (i = 0, 
                    this.input.set.call(this)), 1 == s.length && s[0].node.classList.contains(this.settings.classNames.tagNotAllowed) && (e = !0), 
                    s.length) return this.settings.hooks.beforeRemoveTag(s, {
                        tagify: this
                    }).then((() => {
                        function t(t) {
                            t.node.parentNode && (t.node.parentNode.removeChild(t.node), e ? this.settings.keepInvalidTags && this.trigger("remove", {
                                tag: t.node,
                                index: t.idx
                            }) : (this.trigger("remove", {
                                tag: t.node,
                                index: t.idx,
                                data: t.data
                            }), this.dropdown.refilter(), this.dropdown.position(), this.DOM.input.normalize(), 
                            this.settings.keepInvalidTags && this.reCheckInvalidTags()));
                        }
                        i && i > 10 && 1 == s.length ? function(e) {
                            e.node.style.width = parseFloat(window.getComputedStyle(e.node).width) + "px", document.body.clientTop, 
                            e.node.classList.add(this.settings.classNames.tagHide), setTimeout(t.bind(this), i, e);
                        }.call(this, s[0]) : s.forEach(t.bind(this)), e || (this.removeTagsFromValue(s.map((t => t.node))), 
                        this.update(), "select" == this.settings.mode && this.setContentEditable(!0));
                    })).catch((t => {}));
                },
                removeTagsFromDOM() {
                    [].slice.call(this.getTagElms()).forEach((t => t.parentNode.removeChild(t)));
                },
                removeTagsFromValue(t) {
                    (t = Array.isArray(t) ? t : [ t ]).forEach((t => {
                        var e = this.tagData(t), i = this.getTagIdx(e);
                        i > -1 && this.value.splice(i, 1);
                    }));
                },
                removeAllTags(t) {
                    t = t || {}, this.value = [], "mix" == this.settings.mode ? this.DOM.input.innerHTML = "" : this.removeTagsFromDOM(), 
                    this.dropdown.position(), "select" == this.settings.mode && (this.input.set.call(this), 
                    this.setContentEditable(!0)), this.update(t);
                },
                postUpdate() {
                    var t = this.settings.classNames, e = "mix" == this.settings.mode ? this.settings.mixMode.integrated ? this.DOM.input.textContent : this.DOM.originalInput.value.trim() : this.value.length + this.input.raw.call(this).length;
                    this.toggleClass(t.hasMaxTags, this.value.length >= this.settings.maxTags), this.toggleClass(t.hasNoTags, !this.value.length), 
                    this.toggleClass(t.empty, !e);
                },
                setOriginalInputValue(t) {
                    var e = this.DOM.originalInput;
                    this.settings.mixMode.integrated || (e.value = t, e.tagifyValue = e.value, this.setPersistedData(t, "value"));
                },
                update(t) {
                    var e = this.getInputValue();
                    this.setOriginalInputValue(e), this.postUpdate(), (t || {}).withoutChangeEvent || this.state.blockChangeEvent || this.triggerChangeEvent();
                },
                getInputValue() {
                    var t = this.getCleanValue();
                    return "mix" == this.settings.mode ? this.getMixedTagsAsString(t) : t.length ? this.settings.originalInputValueFormat ? this.settings.originalInputValueFormat(t) : JSON.stringify(t) : "";
                },
                getCleanValue(t) {
                    return a(t || this.value, this.dataProps);
                },
                getMixedTagsAsString() {
                    var t = "", e = this, i = this.settings.mixTagsInterpolator;
                    return function s(a) {
                        a.childNodes.forEach((a => {
                            if (1 == a.nodeType) {
                                const o = e.tagData(a);
                                if ("BR" == a.tagName && (t += "\r\n"), a.getAttribute("style") || [ "B", "I", "U" ].includes(a.tagName)) t += a.textContent; else if ("DIV" == a.tagName || "P" == a.tagName) t += "\r\n", 
                                s(a); else if (v.call(e, a) && o) {
                                    if (o.__removed) return;
                                    t += i[0] + JSON.stringify(n(o, e.dataProps)) + i[1];
                                }
                            } else t += a.textContent;
                        }));
                    }(this.DOM.input), t;
                }
            }, M.prototype.removeTag = M.prototype.removeTags, M;
        }));
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => QueryTags
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _wordpress_data__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(303);
        var _wordpress_data__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(_wordpress_data__WEBPACK_IMPORTED_MODULE_1__);
        var _yaireo_tagify__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(301);
        var _yaireo_tagify__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(_yaireo_tagify__WEBPACK_IMPORTED_MODULE_2__);
        var _tags__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(300);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function Tagify(props) {
            var tagifyRef = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState2 = _slicedToArray(_useState, 2), tagifyInstance = _useState2[0], setTagify = _useState2[1];
            var value = props.value, placeholder = props.placeholder, whitelist = props.whitelist, _onChange = props.onChange, onWhitelistChange = props.onWhitelistChange, className = props.className, onInput = props.onInput;
            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useEffect)((function() {
                if (tagifyInstance && whitelist.length > 0) {
                    var newItems = whitelist.filter((function(item, index) {
                        return tagifyInstance.whitelist.findIndex((function(i) {
                            return i.value === item.value;
                        })) === -1;
                    }));
                    if (newItems.length > 0) {
                        tagifyInstance.whitelist = newItems.concat(tagifyInstance.whitelist);
                        if (onWhitelistChange) {
                            onWhitelistChange(tagifyInstance, tagifyInstance.whitelist);
                        }
                    }
                }
            }), [ whitelist, tagifyInstance ]);
            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useEffect)((function() {
                if (!tagifyRef.current || tagifyInstance) {
                    return;
                }
                var tagify = new (_yaireo_tagify__WEBPACK_IMPORTED_MODULE_2___default())(tagifyRef.current, {
                    tagTextProp: "label",
                    skipInvalid: true,
                    enforceWhitelist: true,
                    templates: {
                        tag: _tags__WEBPACK_IMPORTED_MODULE_3__.tagTemplate,
                        dropdownItem: _tags__WEBPACK_IMPORTED_MODULE_3__.suggestionItemTemplate
                    },
                    dropdown: {
                        closeOnSelect: false,
                        enabled: 0,
                        searchKeys: [ "value", "label" ]
                    }
                });
                if (onInput) {
                    tagify.on("input", (function(ev) {
                        var _ev$detail;
                        onInput(ev === null || ev === void 0 ? void 0 : (_ev$detail = ev.detail) === null || _ev$detail === void 0 ? void 0 : _ev$detail.value, tagify);
                    }));
                }
                setTagify(tagify);
            }), [ tagifyRef ]);
            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useEffect)((function() {
                return function() {
                    if (tagifyInstance) {
                        tagifyInstance.destroy();
                    }
                };
            }), [ tagifyInstance ]);
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("input", {
                placeholder,
                className,
                ref: tagifyRef,
                type: "text",
                value,
                onChange: function onChange(ev) {
                    _onChange(ev.target.value ? JSON.parse(ev.target.value).map((function(e) {
                        return e.value;
                    })) : []);
                }
            });
        }
        function QueryTags(_ref) {
            var value = _ref.value, onChange = _ref.onChange, options = _ref.options, id = _ref.id;
            var _useState3 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(null), _useState4 = _slicedToArray(_useState3, 2), keyword = _useState4[0], setKeyword = _useState4[1];
            var query = options.query;
            var _useSelect = (0, _wordpress_data__WEBPACK_IMPORTED_MODULE_1__.useSelect)((function(select) {
                var _select = select("core"), getEntityRecords = _select.getEntityRecords, getUsers = _select.getUsers;
                var generalQueryArgs = {
                    per_page: 10
                };
                if (keyword) {
                    if (keyword.length >= 2) {
                        generalQueryArgs["search"] = keyword;
                    }
                } else {
                    if (Array.isArray(value)) {
                        generalQueryArgs["include"] = value;
                    }
                }
                if (!generalQueryArgs.search && !generalQueryArgs.include) {
                    return {
                        whitelist: []
                    };
                }
                if ((query === null || query === void 0 ? void 0 : query.type) === "user") {
                    var _result2;
                    var _result = getUsers(generalQueryArgs);
                    _result = ((_result2 = _result) !== null && _result2 !== void 0 ? _result2 : []).map((function(_ref2) {
                        var id = _ref2.id, name = _ref2.name;
                        return {
                            value: id,
                            label: name
                        };
                    }));
                    return {
                        whitelist: _result
                    };
                }
                var result = [];
                var queryArgs;
                if ((query === null || query === void 0 ? void 0 : query.type) === "post") {
                    queryArgs = [ "postType", "post" ];
                } else if ((query === null || query === void 0 ? void 0 : query.type) === "page") {
                    queryArgs = [ "postType", "page" ];
                } else if ((query === null || query === void 0 ? void 0 : query.type) === "taxonomy" && query !== null && query !== void 0 && query.slug) {
                    queryArgs = [ "taxonomy", query === null || query === void 0 ? void 0 : query.slug ];
                }
                if (queryArgs) {
                    var _result3;
                    result = getEntityRecords.apply(void 0, _toConsumableArray(queryArgs).concat([ generalQueryArgs ]));
                    result = ((_result3 = result) !== null && _result3 !== void 0 ? _result3 : []).map((function(_ref3) {
                        var id = _ref3.id, title = _ref3.title, name = _ref3.name;
                        return {
                            value: id,
                            label: (title === null || title === void 0 ? void 0 : title.rendered) || name
                        };
                    }));
                }
                return {
                    whitelist: result
                };
            }), [ keyword, query ]), whitelist = _useSelect.whitelist;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(Tagify, {
                value,
                placeholder: "search",
                onChange,
                whitelist,
                onWhitelistChange: function onWhitelistChange(tagify) {
                    tagify.loading(false);
                    tagify.dropdown.show(keyword);
                },
                onInput: function onInput(value, tagify) {
                    if (value.length >= 2) {
                        tagify.loading(true);
                    }
                    setKeyword(value);
                },
                className: "lotta-query-tags"
            });
        }
    }, module => {
        "use strict";
        module.exports = window.wp.data;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _wordpress_components__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(253);
        var _wordpress_components__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        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);
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        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);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        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;
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var ImageUploader = function(_Component) {
            _inherits(ImageUploader, _Component);
            var _super = _createSuper(ImageUploader);
            function ImageUploader() {
                var _this;
                _classCallCheck(this, ImageUploader);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "params", {
                    height: 250,
                    width: 250,
                    flex_width: true,
                    flex_height: true
                });
                _defineProperty(_assertThisInitialized(_this), "state", {
                    attachment_info: null
                });
                _defineProperty(_assertThisInitialized(_this), "onSelect", (function() {
                    var attachment = _this.frame.state().get("selection").first().toJSON();
                    if ((_this.props.options.logo || {}).width === attachment.width && (_this.props.options.logo || {}).height === attachment.height && !(_this.props.options.logo || {}).flex_width && !(_this.props.options.logo || {}).flex_height || _this.props.options.skipCrop || true) {
                        _this.setImageFromAttachment(attachment);
                        _this.frame.close();
                    } else {}
                }));
                _defineProperty(_assertThisInitialized(_this), "onCropped", (function(croppedImage) {
                    _this.setImageFromAttachment(croppedImage);
                }));
                _defineProperty(_assertThisInitialized(_this), "onSkippedCrop", (function() {
                    var attachment = _this.frame.state().get("selection").first().toJSON();
                    _this.setImageFromAttachment(attachment);
                }));
                _defineProperty(_assertThisInitialized(_this), "onChange", (function(value) {
                    var attachment_info = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
                    _this.props.onChange(_this.props.options.inlineValue ? value || "" : _objectSpread(_objectSpread({}, _this.props.value), {}, {
                        url: _this.getUrlFor(attachment_info),
                        attachment_id: value
                    }));
                }));
                _defineProperty(_assertThisInitialized(_this), "updateAttachmentInfo", (function() {
                    var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
                    var id = _this.getAttachmentId();
                    if (!id) {
                        if (_this.props.value.url) {
                            _this.setState({
                                attachment_info: {
                                    url: _this.props.value.url
                                }
                            });
                        }
                        return;
                    }
                    if (!wp.media.attachment(id).get("url") || force) {
                        wp.media.attachment(id).fetch().then((function() {
                            _this.setState({
                                attachment_info: JSON.parse(JSON.stringify(wp.media.attachment(id).toJSON()))
                            });
                        }));
                    } else {
                        _this.setState({
                            attachment_info: JSON.parse(JSON.stringify(wp.media.attachment(id).toJSON()))
                        });
                    }
                    _this.detachListener();
                    wp.media.attachment(id).on("change", _this.updateAttachmentInfo);
                }));
                _defineProperty(_assertThisInitialized(_this), "getAttachmentId", (function() {
                    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props;
                    return props.options.inlineValue ? props.value : props.value.attachment_id;
                }));
                _defineProperty(_assertThisInitialized(_this), "getUrlFor", (function(attachmentInfo) {
                    return attachmentInfo ? attachmentInfo.sizes ? attachmentInfo.sizes.full.url || attachmentInfo.url : attachmentInfo.url : null;
                }));
                return _this;
            }
            _createClass(ImageUploader, [ {
                key: "initFrame",
                value: function initFrame() {
                    var _this2 = this;
                    this.frame = wp.media({
                        button: {
                            text: "Select",
                            close: false
                        },
                        states: [ new wp.media.controller.Library({
                            title: "Select File",
                            library: wp.media.query({
                                type: this.props.options.mediaType || "image"
                            }),
                            multiple: false,
                            date: false,
                            priority: 20,
                            suggestedWidth: (this.props.options.logo || {}).width,
                            suggestedHeight: (this.props.options.logo || {}).height
                        }) ].concat(_toConsumableArray(this.props.options.skipCrop || true ? [] : 0))
                    });
                    this.frame.on("select", this.onSelect, this);
                    this.frame.on("close", (function() {
                        _this2.props.options.onFrameClose && _this2.props.options.onFrameClose();
                    }));
                    this.frame.on("cropped", this.onCropped, this);
                    this.frame.on("skippedcrop", this.onSkippedCrop, this);
                }
            }, {
                key: "openFrame",
                value: function openFrame() {
                    this.initFrame();
                    this.frame.setState("library").open();
                    this.props.options.onFrameOpen && this.props.options.onFrameOpen();
                }
            }, {
                key: "setImageFromAttachment",
                value: function setImageFromAttachment(attachment) {
                    this.onChange(attachment.id, JSON.parse(JSON.stringify(wp.media.attachment(attachment.id).toJSON())));
                    this.updateAttachmentInfo();
                }
            }, {
                key: "detachListener",
                value: function detachListener() {
                    if (!this.getAttachmentId()) return;
                    wp.media.attachment(this.getAttachmentId()).off("change", this.updateAttachmentInfo);
                }
            }, {
                key: "componentDidUpdate",
                value: function componentDidUpdate(prevProps) {
                    if (this.getAttachmentId() !== this.getAttachmentId(prevProps)) {
                        wp.media.attachment(this.getAttachmentId(prevProps)).off("change", this.updateAttachmentInfo);
                        this.updateAttachmentInfo();
                    }
                }
            }, {
                key: "componentDidMount",
                value: function componentDidMount() {
                    this.updateAttachmentInfo();
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    this.detachListener();
                }
            }, {
                key: "render",
                value: function render() {
                    var _clsx, _this3 = this;
                    var _this$props$options = this.props.options, positionPicker = _this$props$options.positionPicker, emptyLabel = _this$props$options.emptyLabel;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("lotta-image-uploader", (_clsx = {}, 
                        _defineProperty(_clsx, "landscape", this.state.attachment_info), _defineProperty(_clsx, "attachment-media-view-image", this.state.attachment_info), 
                        _clsx)),
                        children: this.state.attachment_info ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                            className: "thumbnail thumbnail-image",
                            onClick: function onClick() {
                                return !positionPicker && _this3.openFrame();
                            },
                            children: [ !positionPicker && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("img", {
                                className: "attachment-thumb",
                                src: this.getUrlFor(this.state.attachment_info),
                                draggable: "false",
                                alt: ""
                            }), positionPicker && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__.FocalPointPicker, {
                                url: this.getUrlFor(this.state.attachment_info),
                                dimensions: {
                                    width: 400,
                                    height: 100
                                },
                                value: Object.assign({}, {
                                    x: 0,
                                    y: 0
                                }, this.props.value),
                                onChange: function onChange(drag_position) {
                                    _this3.props.onChange(_objectSpread(_objectSpread({}, _this3.props.value), drag_position));
                                }
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                                className: "actions",
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("button", {
                                    type: "button",
                                    className: "button edit-button control-focus",
                                    title: "Edit",
                                    onClick: function onClick(e) {
                                        e.stopPropagation();
                                        _this3.openFrame();
                                    }
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("button", {
                                    onClick: function onClick(e) {
                                        e.stopPropagation();
                                        _this3.setState({
                                            attachment_info: null
                                        });
                                        _this3.onChange(null);
                                    },
                                    title: "Remove",
                                    type: "button",
                                    className: "button remove-button"
                                }) ]
                            }) ]
                        }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("button", {
                            type: "button",
                            onClick: function onClick() {
                                return _this3.openFrame();
                            },
                            className: "button lotta-upload-button",
                            children: emptyLabel || "Select Image"
                        })
                    });
                }
            } ]);
            return ImageUploader;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = ImageUploader;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(190);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var _components_react_color_picker__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(252);
        var _components_gradient_picker__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(306);
        var _image_uploader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(304);
        var _index__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(5);
        var _utils__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(4);
        var _image_radio__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(273);
        var _radio__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(271);
        var _color_picker__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(189);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(254);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(10);
        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);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var BackgroundImage = function(_Component) {
            _inherits(BackgroundImage, _Component);
            var _super = _createSuper(BackgroundImage);
            function BackgroundImage() {
                _classCallCheck(this, BackgroundImage);
                return _super.apply(this, arguments);
            }
            _createClass(BackgroundImage, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, value = _this$props.value, _onChange = _this$props.onChange;
                    value = Object.assign({}, {
                        source: {},
                        repeat: "no-repeat",
                        size: "cover",
                        attachment: "scroll",
                        color: "#ccc"
                    }, value);
                    var sections = [ {
                        id: "repeat",
                        value: value.repeat,
                        component: _image_radio__WEBPACK_IMPORTED_MODULE_8__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_11__.__)("Background Repeat"),
                            inline: true,
                            choices: {
                                repeat: {
                                    src: '<svg width="13px" height="13px" viewBox="0 0 16 16"><path d="M0,0h4v4H0V0z M6,0h4v4H6V0z M12,0h4v4h-4V0z M0,6h4v4H0V6z M6,6h4v4H6V6z M12,6h4v4h-4V6z M0,12h4v4H0V12z M6,12h4v4H6V12zM12,12h4v4h-4V12z"></path></svg>',
                                    title: "Repeat"
                                },
                                "repeat-y": {
                                    src: '<svg width="13px" height="13px" viewBox="0 0 16 16"><rect x="6" width="4" height="4"></rect><rect x="6" y="6" width="4" height="4"></rect><rect x="6" y="12" width="4" height="4"></rect></svg>',
                                    title: "Repeat Y"
                                },
                                "repeat-x": {
                                    src: '<svg width="13px" height="13px" viewBox="0 0 16 16"><rect y="6" width="4" height="4"></rect><rect x="6" y="6" width="4" height="4"></rect><rect x="12" y="6" width="4" height="4"></rect></svg>',
                                    title: "Repeat X"
                                },
                                "no-repeat": {
                                    src: '<svg width="13px" height="13px" viewBox="0 0 16 16"><rect x="6" y="6" width="4" height="4"></rect></svg>',
                                    title: "No Repeat"
                                }
                            }
                        }
                    }, {
                        id: "size",
                        value: value.size,
                        component: _radio__WEBPACK_IMPORTED_MODULE_9__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_11__.__)("Background Size"),
                            attr: {
                                "data-columns": 3
                            },
                            choices: {
                                auto: "Auto",
                                cover: "Cover",
                                contain: "Contain"
                            }
                        }
                    }, {
                        id: "attachment",
                        value: value.attachment,
                        component: _radio__WEBPACK_IMPORTED_MODULE_9__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_11__.__)("Background Attachment"),
                            attr: {
                                "data-columns": 3
                            },
                            choices: {
                                scroll: "Scroll",
                                fixed: "Fixed",
                                inherit: "Inherit"
                            }
                        }
                    }, {
                        id: "color",
                        value: {
                            initial: value.color
                        },
                        component: _color_picker__WEBPACK_IMPORTED_MODULE_10__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_11__.__)("Background Color"),
                            type: "lotta-color-picker",
                            alpha: true,
                            colors: [ {
                                title: "Initial",
                                id: "initial"
                            } ]
                        },
                        onChange: function onChange(v) {
                            return v.initial;
                        }
                    } ];
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsxs)("div", {
                        className: "lotta-background-image",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)(_image_uploader__WEBPACK_IMPORTED_MODULE_5__["default"], {
                            value: value.source,
                            options: {
                                positionPicker: true,
                                onFrameOpen: this.props.onFrameOpen,
                                onFrameClose: this.props.onFrameClose
                            },
                            onChange: function onChange(v) {
                                return _onChange(_objectSpread(_objectSpread({}, value), {}, {
                                    source: v
                                }));
                            }
                        }), sections.map((function(s) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("div", {
                                children: (0, _index__WEBPACK_IMPORTED_MODULE_6__.buildControl)({
                                    value: s.value,
                                    options: s.options || {},
                                    params: s.params || {},
                                    Component: s.component,
                                    onChange: function onChange(v) {
                                        v = s.onChange ? s.onChange(v) : v;
                                        _onChange(_objectSpread(_objectSpread({}, value), {}, _defineProperty({}, s.id, v)));
                                    }
                                })
                            }, s.id);
                        })) ]
                    });
                }
            } ]);
            return BackgroundImage;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var BackgroundModal = function BackgroundModal(_ref) {
            var value = _ref.value, _onChange2 = _ref.onChange, onFrameOpen = _ref.onFrameOpen, onFrameClose = _ref.onFrameClose;
            var type = value.type, color = value.color, gradient = value.gradient, image = value.image;
            type = type || color;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsxs)("div", {
                className: "lotta-background-modal",
                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsxs)("ul", {
                    className: "lotta-modal-tabs",
                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("li", {
                        "data-bg-type": "color",
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                            active: type === "color"
                        }),
                        onClick: function onClick() {
                            return _onChange2({
                                type: "color",
                                color,
                                gradient,
                                image
                            });
                        },
                        children: "Color"
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("li", {
                        "data-bg-type": "gradient",
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                            active: type === "gradient"
                        }),
                        onClick: function onClick() {
                            return _onChange2({
                                type: "gradient",
                                color,
                                gradient,
                                image
                            });
                        },
                        children: "Gradient"
                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("li", {
                        "data-bg-type": "image",
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                            active: type === "image"
                        }),
                        onClick: function onClick() {
                            return _onChange2({
                                type: "image",
                                color,
                                gradient,
                                image
                            });
                        },
                        children: "Image"
                    }) ]
                }), type === "color" && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("div", {
                    className: "modal-content",
                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)(_components_react_color_picker__WEBPACK_IMPORTED_MODULE_3__["default"], {
                        swatches: window.Lotta && window.Lotta.customizer && window.Lotta.customizer.colorPicker ? (0, 
                        _utils__WEBPACK_IMPORTED_MODULE_7__.sanitize_array_value)(window.Lotta.customizer.colorPicker.swatches) : [],
                        enableAlpha: true,
                        color: (0, _utils__WEBPACK_IMPORTED_MODULE_7__.getColorValue)(color),
                        onChange: function onChange(v) {
                            return _onChange2({
                                color: v,
                                type,
                                gradient,
                                image
                            });
                        }
                    })
                }), type === "gradient" && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("div", {
                    className: "modal-content",
                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)(_components_gradient_picker__WEBPACK_IMPORTED_MODULE_4__["default"], {
                        gradient,
                        onChange: function onChange(v) {
                            return _onChange2({
                                gradient: v,
                                type,
                                color,
                                image
                            });
                        }
                    })
                }), type === "image" && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("div", {
                    className: "modal-content",
                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)(BackgroundImage, {
                        value: image,
                        onChange: function onChange(v) {
                            return _onChange2({
                                image: v,
                                type,
                                color,
                                gradient
                            });
                        },
                        onFrameOpen,
                        onFrameClose
                    })
                }) ]
            });
        };
        var Background = function Background(_ref2) {
            var value = _ref2.value, _onChange3 = _ref2.onChange;
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.useState)(false), _useState2 = _slicedToArray(_useState, 2), outsideClickDisabled = _useState2[0], setOutsideClickDisabled = _useState2[1];
            var preview = {};
            value = Object.assign({
                type: "color",
                color: _index__WEBPACK_IMPORTED_MODULE_6__.CSS_INITIAL_VALUE
            }, value);
            if (value["type"] === "color") {
                preview["backgroundColor"] = value["color"] || "";
            }
            if (value["type"] === "gradient") {
                preview["backgroundImage"] = value["gradient"] || "";
            }
            if (value["type"] === "image") {
                var _ref3 = value["image"] || {}, _ref3$source = _ref3.source, source = _ref3$source === void 0 ? {} : _ref3$source, size = _ref3.size, repeat = _ref3.repeat, attachment = _ref3.attachment, color = _ref3.color;
                preview["backgroundColor"] = color;
                preview["backgroundSize"] = size;
                preview["backgroundRepeat"] = repeat;
                preview["backgroundAttachment"] = attachment;
                preview["backgroundImage"] = "url(" + source.url + ")";
                preview["backgroundPosition"] = "".concat((source.x || 0) * 100, "% ").concat((source.y || 0) * 100, "%");
            }
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_1__["default"], {
                disableOutsideClick: outsideClickDisabled,
                placement: "bottom",
                content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)(BackgroundModal, {
                    value,
                    onChange: function onChange(value) {
                        _onChange3(value);
                    },
                    onFrameOpen: function onFrameOpen() {
                        return setOutsideClickDisabled(true);
                    },
                    onFrameClose: function onFrameClose() {
                        return setOutsideClickDisabled(false);
                    }
                }),
                children: function children(_ref4) {
                    var props = _ref4.props;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("div", _objectSpread(_objectSpread({}, props), {}, {
                        className: "lotta-background-preview-box",
                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_12__.jsx)("div", {
                            className: "lotta-background-preview",
                            style: preview
                        })
                    }));
                }
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Background;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_components__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(253);
        var _wordpress_components__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_components__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
        var GradientPicker = function GradientPicker(_ref) {
            var gradient = _ref.gradient, _onChange = _ref.onChange, swatches = _ref.swatches;
            if (!swatches && window.Lotta && window.Lotta.customizer && window.Lotta.customizer.gradientPicker) {
                swatches = window.Lotta.customizer.gradientPicker.swatches;
            }
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
                className: "lotta-gradient-picker",
                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)(_wordpress_components__WEBPACK_IMPORTED_MODULE_0__.GradientPicker, {
                    className: "wp-gradient-picker",
                    value: gradient || null,
                    gradients: [],
                    onChange: function onChange(currentGradient) {
                        _onChange(currentGradient);
                    }
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("ul", {
                    className: "lotta-gradient-switches",
                    children: (0, _utils__WEBPACK_IMPORTED_MODULE_2__.sanitize_array_value)(swatches).map((function(swatch, index) {
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("li", {
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])({
                                active: swatch.gradient === gradient
                            }),
                            style: {
                                "--background-image": swatch.gradient
                            },
                            onClick: function onClick() {
                                _onChange(swatch.gradient);
                            }
                        }, index);
                    }))
                }) ]
            });
        };
        const __WEBPACK_DEFAULT_EXPORT__ = GradientPicker;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(190);
        var _color_picker__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(189);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(254);
        var _toggle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(176);
        var _index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5);
        var _slider__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(174);
        var clsx__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var BoxShadow = function BoxShadow(_ref) {
            var value = _ref.value, options = _ref.options, _onChange = _ref.onChange;
            value = Object.assign({
                inherit: value === _index__WEBPACK_IMPORTED_MODULE_4__.CSS_INITIAL_VALUE,
                enable: false
            }, value);
            var sections = [ {
                id: "enable",
                component: _toggle__WEBPACK_IMPORTED_MODULE_3__["default"],
                options: {
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Enable")
                }
            }, {
                id: "horizontal",
                component: _slider__WEBPACK_IMPORTED_MODULE_5__["default"],
                options: {
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Horizontal Offset"),
                    min: -100,
                    max: 100,
                    defaultUnit: "px"
                }
            }, {
                id: "vertical",
                component: _slider__WEBPACK_IMPORTED_MODULE_5__["default"],
                options: {
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Vertical Offset"),
                    min: -100,
                    max: 100,
                    defaultUnit: "px"
                }
            }, {
                id: "blur",
                component: _slider__WEBPACK_IMPORTED_MODULE_5__["default"],
                options: {
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Blur"),
                    min: 0,
                    max: 100,
                    defaultUnit: "px"
                }
            }, {
                id: "spread",
                component: _slider__WEBPACK_IMPORTED_MODULE_5__["default"],
                options: {
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Spread"),
                    min: -100,
                    max: 100,
                    defaultUnit: "px"
                }
            } ];
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsxs)("div", {
                className: "lotta-box-shadow",
                children: [ value.enable === "yes" && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(_color_picker__WEBPACK_IMPORTED_MODULE_1__["default"], {
                    options: {
                        alpha: true,
                        colors: [ {
                            id: "color",
                            title: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Color")
                        } ]
                    },
                    value: {
                        color: value.color || ""
                    },
                    onChange: function onChange(c) {
                        _onChange(_objectSpread(_objectSpread({}, value), c));
                    }
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_0__["default"], {
                    content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", {
                        className: "box-shadow-modal",
                        children: sections.map((function(s) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", {
                                className: "box-shadow-section",
                                children: (0, _index__WEBPACK_IMPORTED_MODULE_4__.buildControl)({
                                    params: s.params,
                                    options: s.options,
                                    value: value[s.id] || "",
                                    Component: s.component,
                                    onChange: function onChange(v) {
                                        _onChange(_objectSpread(_objectSpread({}, value), {}, _defineProperty({}, s.id, v)));
                                    }
                                })
                            }, s.id);
                        }))
                    }),
                    children: function children(_ref2) {
                        var props = _ref2.props, isOpen = _ref2.isOpen;
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_7__.jsx)("div", _objectSpread(_objectSpread({
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_6__["default"])({
                                "lotta-modal-value": true,
                                "lotta-modal-value-active": isOpen
                            })
                        }, props), {}, {
                            children: value.enable === "yes" ? (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Adjust") : value.inherit ? (0, 
                            _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Inherit") : (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("None")
                        }));
                    }
                }) ]
            });
        };
        BoxShadow.renderingConfig = {
            design: "inline"
        };
        const __WEBPACK_DEFAULT_EXPORT__ = BoxShadow;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Typography
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(190);
        var _slider__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(174);
        var bezier_easing__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(188);
        var bezier_easing__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(bezier_easing__WEBPACK_IMPORTED_MODULE_3__);
        var _react_spring_web__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(180);
        var _index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
        var _utils__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4);
        var _components_fonts_list__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(309);
        var _components_variants_list__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(312);
        var _control_wrapper__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(7);
        var clsx__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(9);
        var _components_tooltip__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(251);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(254);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(10);
        var react__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_14___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_14__);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Typography = function(_Component) {
            _inherits(Typography, _Component);
            var _super = _createSuper(Typography);
            function Typography() {
                var _this;
                _classCallCheck(this, Typography);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    currentView: "options",
                    previousView: "-"
                });
                _defineProperty(_assertThisInitialized(_this), "setView", (function(view) {
                    _this.setState({
                        currentView: view,
                        previousView: _this.state.currentView
                    });
                }));
                _defineProperty(_assertThisInitialized(_this), "onFontChange", (function(value) {
                    _this.onChange("family", value);
                }));
                _defineProperty(_assertThisInitialized(_this), "onVariantChange", (function(value) {
                    _this.onChange("variant", value);
                }));
                _defineProperty(_assertThisInitialized(_this), "onTextTransformChange", (function(value) {
                    if (_this.props.value && _this.props.value.textTransform === value) {
                        value = "";
                    }
                    _this.onChange("textTransform", value);
                }));
                _defineProperty(_assertThisInitialized(_this), "onTextDecorationChange", (function(value) {
                    if (_this.props.value && _this.props.value.textDecoration === value) {
                        value = "";
                    }
                    _this.onChange("textDecoration", value);
                }));
                _defineProperty(_assertThisInitialized(_this), "onChange", (function(key, value) {
                    _this.props.onChange(_objectSpread(_objectSpread({}, _this.props.value), {}, _defineProperty({}, key, value)));
                }));
                return _this;
            }
            _createClass(Typography, [ {
                key: "direction",
                get: function get() {
                    var _this$state = this.state, currentView = _this$state.currentView, previousView = _this$state.previousView;
                    if (previousView === "-") {
                        return "static";
                    }
                    if (previousView === "options") {
                        return currentView === "fonts" ? "right" : "left";
                    }
                    if (previousView === "fonts") {
                        return "left";
                    }
                    if (previousView === "variants") {
                        return "right";
                    }
                    return "left";
                }
            }, {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props$value = this.props.value, family = _this$props$value.family, variant = _this$props$value.variant, fontSize = _this$props$value.fontSize, textTransform = _this$props$value.textTransform, textDecoration = _this$props$value.textDecoration;
                    family = family || "inherit";
                    var sections = [ {
                        id: "fontSize",
                        component: _slider__WEBPACK_IMPORTED_MODULE_2__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)("Font Size"),
                            responsive: true,
                            units: [ {
                                unit: "px",
                                min: 10,
                                max: 200,
                                step: 1
                            }, {
                                unit: "pt",
                                min: 10,
                                max: 50,
                                step: 1
                            }, {
                                unit: "em",
                                min: .5,
                                max: 50,
                                step: .1
                            }, {
                                unit: "rem",
                                min: .5,
                                max: 50,
                                step: .1
                            } ]
                        }
                    }, {
                        id: "lineHeight",
                        component: _slider__WEBPACK_IMPORTED_MODULE_2__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)("Line Height"),
                            responsive: true,
                            units: [ {
                                unit: "",
                                min: 1,
                                max: 10
                            }, {
                                unit: "px",
                                min: 10,
                                max: 100
                            }, {
                                unit: "pt",
                                min: 10,
                                max: 100
                            }, {
                                unit: "em",
                                min: 1,
                                max: 100
                            }, {
                                unit: "rem",
                                min: 1,
                                max: 100
                            } ]
                        }
                    }, {
                        id: "letterSpacing",
                        component: _slider__WEBPACK_IMPORTED_MODULE_2__["default"],
                        options: {
                            label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)("Letter Spacing"),
                            responsive: true,
                            units: [ {
                                unit: "px",
                                min: -20,
                                max: 20,
                                step: 1
                            }, {
                                unit: "pt",
                                min: -20,
                                max: 20,
                                step: 1
                            }, {
                                unit: "em",
                                min: -10,
                                max: 10,
                                step: .1
                            }, {
                                unit: "rem",
                                min: -10,
                                max: 10,
                                step: .1
                            } ]
                        }
                    } ];
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_1__["default"], {
                        toggleable: false,
                        content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("div", {
                            className: "lotta-typography-modal",
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("div", {
                                className: "typography-panels",
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_react_spring_web__WEBPACK_IMPORTED_MODULE_4__.Transition, {
                                    items: this.state.currentView,
                                    immediate: this.direction === "static",
                                    config: function config() {
                                        return {
                                            duration: 210,
                                            easing: bezier_easing__WEBPACK_IMPORTED_MODULE_3___default()(.455, .03, .515, .955)
                                        };
                                    },
                                    from: {
                                        position: "absolute",
                                        transform: this.direction === "left" ? "translateX(100%)" : "translateX(-100%)"
                                    },
                                    enter: {
                                        position: "absolute",
                                        transform: "translateX(0%)"
                                    },
                                    leave: {
                                        position: "absolute",
                                        transform: this.direction === "left" ? "translateX(-100%)" : "translateX(100%)"
                                    },
                                    children: function children(props, view) {
                                        if (view === "fonts") {
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_react_spring_web__WEBPACK_IMPORTED_MODULE_4__.animated.div, {
                                                style: props,
                                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_components_fonts_list__WEBPACK_IMPORTED_MODULE_7__["default"], {
                                                    family,
                                                    onChange: _this2.onFontChange
                                                })
                                            });
                                        }
                                        if (view === "variants") {
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_react_spring_web__WEBPACK_IMPORTED_MODULE_4__.animated.div, {
                                                style: props,
                                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_components_variants_list__WEBPACK_IMPORTED_MODULE_8__["default"], {
                                                    family,
                                                    variant,
                                                    onChange: _this2.onVariantChange
                                                })
                                            });
                                        }
                                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsxs)(_react_spring_web__WEBPACK_IMPORTED_MODULE_4__.animated.div, {
                                            style: props,
                                            children: [ sections.map((function(s) {
                                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("div", {
                                                    className: "typography-section",
                                                    children: (0, _index__WEBPACK_IMPORTED_MODULE_5__.buildControl)({
                                                        params: s.params,
                                                        options: s.options,
                                                        value: _this2.props.value[s.id] || "",
                                                        Component: s.component,
                                                        onChange: function onChange(value) {
                                                            _this2.onChange(s.id, value);
                                                        }
                                                    })
                                                }, s.id);
                                            })), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsxs)("div", {
                                                className: "typography-section lotta-text-variants",
                                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("ul", {
                                                    className: "lotta-buttons-group text-transform",
                                                    children: [ "capitalize", "uppercase", "lowercase" ].map((function(variant) {
                                                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_components_tooltip__WEBPACK_IMPORTED_MODULE_11__["default"], {
                                                            content: (0, _utils__WEBPACK_IMPORTED_MODULE_6__.capitalize)(variant),
                                                            placement: "top",
                                                            children: function children(_ref) {
                                                                var props = _ref.props;
                                                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("li", _objectSpread(_objectSpread({}, props), {}, {
                                                                    "data-variant": variant,
                                                                    onClick: function onClick() {
                                                                        return _this2.onTextTransformChange(variant);
                                                                    },
                                                                    className: textTransform === variant ? "active" : ""
                                                                }));
                                                            }
                                                        }, variant);
                                                    }))
                                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("ul", {
                                                    className: "lotta-buttons-group text-decoration",
                                                    children: [ "line-through", "underline" ].map((function(variant) {
                                                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)(_components_tooltip__WEBPACK_IMPORTED_MODULE_11__["default"], {
                                                            content: (0, _utils__WEBPACK_IMPORTED_MODULE_6__.capitalize)(variant),
                                                            placement: "top",
                                                            children: function children(_ref2) {
                                                                var props = _ref2.props;
                                                                return (0, react__WEBPACK_IMPORTED_MODULE_14__.createElement)("li", _objectSpread(_objectSpread({}, props), {}, {
                                                                    key: variant,
                                                                    "data-variant": variant,
                                                                    onClick: function onClick() {
                                                                        return _this2.onTextDecorationChange(variant);
                                                                    },
                                                                    className: textDecoration === variant ? "active" : ""
                                                                }));
                                                            }
                                                        }, variant);
                                                    }))
                                                }) ]
                                            }) ]
                                        });
                                    }
                                })
                            })
                        }),
                        children: function children(_ref3) {
                            var props = _ref3.props, isOpen = _ref3.isOpen;
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsxs)("ul", _objectSpread(_objectSpread({}, props), {}, {
                                className: "lotta-buttons-group",
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("li", {
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_10__["default"])({
                                        active: isOpen && _this2.state.currentView === "fonts"
                                    }),
                                    onClick: function onClick() {
                                        return _this2.setView("fonts");
                                    },
                                    children: (0, _components_fonts_list__WEBPACK_IMPORTED_MODULE_7__.getFontName)(family)
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("li", {
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_10__["default"])({
                                        active: isOpen && _this2.state.currentView === "options"
                                    }),
                                    onClick: function onClick() {
                                        return _this2.setView("options");
                                    },
                                    children: (0, _control_wrapper__WEBPACK_IMPORTED_MODULE_9__.promoteScalarValueIntoResponsive)(fontSize)[wp.customize && wp.customize.previewedDevice ? wp.customize.previewedDevice() : "desktop"]
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_13__.jsx)("li", {
                                    className: (0, clsx__WEBPACK_IMPORTED_MODULE_10__["default"])({
                                        active: isOpen && _this2.state.currentView === "variants"
                                    }),
                                    onClick: function onClick() {
                                        return _this2.setView("variants");
                                    },
                                    children: (0, _components_variants_list__WEBPACK_IMPORTED_MODULE_8__.getVariantName)(variant)
                                }) ]
                            }));
                        }
                    });
                }
            } ]);
            return Typography;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            SingleFont: () => SingleFont,
            default: () => FontsList,
            getFontName: () => getFontName,
            isCustomFonts: () => isCustomFonts,
            isGoogleFonts: () => isGoogleFonts,
            loadGoogleFonts: () => loadGoogleFonts
        });
        var react_window__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(285);
        var webfontloader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(310);
        var webfontloader__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(webfontloader__WEBPACK_IMPORTED_MODULE_0__);
        var react_virtualized_auto_sizer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(311);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__);
        var clsx__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9);
        var _utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var isGoogleFonts = function isGoogleFonts(id) {
            if (window.Lotta && window.Lotta.customizer.settings) {
                return !!window.Lotta.customizer.settings.google_fonts[id];
            }
            return false;
        };
        var isCustomFonts = function isCustomFonts(id) {
            if (window.Lotta && window.Lotta.customizer.settings) {
                return !!window.Lotta.customizer.settings.custom_fonts[id];
            }
            return false;
        };
        var loadGoogleFonts = function loadGoogleFonts(fonts) {
            if (fonts.length <= 0 || !window.Lotta || !window.Lotta.customizer.settings) {
                return;
            }
            var google_fonts = window.Lotta.customizer.settings.google_fonts;
            webfontloader__WEBPACK_IMPORTED_MODULE_0___default().load({
                google: {
                    families: fonts.map((function(f) {
                        return google_fonts[f].f;
                    }))
                }
            });
        };
        var getFontName = function getFontName(family) {
            var _window$Lotta$customi = window.Lotta.customizer.settings, custom_fonts = _window$Lotta$customi.custom_fonts, system_fonts = _window$Lotta$customi.system_fonts, google_fonts = _window$Lotta$customi.google_fonts;
            var data = Object.assign({}, custom_fonts, system_fonts, google_fonts);
            return data[family] ? data[family].f : "";
        };
        var SingleFont = function(_Component) {
            _inherits(SingleFont, _Component);
            var _super = _createSuper(SingleFont);
            function SingleFont() {
                _classCallCheck(this, SingleFont);
                return _super.apply(this, arguments);
            }
            _createClass(SingleFont, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, style = _this$props.style, data = _this$props.data, index = _this$props.index, family = _this$props.family, _onClick = _this$props.onClick;
                    var id = data.fonts[index];
                    var font = data.data[id];
                    var font_type = "system";
                    if (isCustomFonts(id)) {
                        font_type = "custom";
                    } else if (isGoogleFonts(id)) {
                        font_type = "google";
                    }
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                        style,
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_3__["default"])("font-item", font_type + "-font-item", {
                            active: family === id
                        }),
                        onClick: function onClick() {
                            return _onClick(id, font);
                        },
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                            className: "font-label",
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                children: font.f
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                className: "font-type-label " + font_type + "-font-type-label",
                                children: (0, _utils__WEBPACK_IMPORTED_MODULE_4__.capitalize)(font_type)
                            }) ]
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("p", {
                            className: "font-preview",
                            style: {
                                fontFamily: font.f
                            },
                            children: "The quick brown fox jumps over the lazy dog."
                        }) ]
                    });
                }
            } ]);
            return SingleFont;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__.Component);
        var FontsList = function(_Component2) {
            _inherits(FontsList, _Component2);
            var _super2 = _createSuper(FontsList);
            function FontsList() {
                var _this;
                _classCallCheck(this, FontsList);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super2.call.apply(_super2, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    filter: ""
                });
                _defineProperty(_assertThisInitialized(_this), "loadWebFontsTimer", null);
                _defineProperty(_assertThisInitialized(_this), "listRef", (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_2__.createRef)());
                _defineProperty(_assertThisInitialized(_this), "loadWebFonts", (function(fonts) {
                    if (_this.loadWebFontsTimer) {
                        clearTimeout(_this.loadWebFontsTimer);
                    }
                    _this.loadWebFontsTimer = setTimeout((function() {
                        if (!_this.listRef.current) {
                            return;
                        }
                        var _this$listRef$current = _this.listRef.current._getRangeToRender(), _this$listRef$current2 = _slicedToArray(_this$listRef$current, 1), overscanStartIndex = _this$listRef$current2[0];
                        var perPage = 10;
                        var startingPage = Math.ceil((overscanStartIndex + 1) / perPage);
                        var webFonts = _toConsumableArray(Array(perPage)).map((function(_, i) {
                            return (startingPage - 1) * perPage + i;
                        })).map((function(index) {
                            return fonts[index];
                        }));
                        (0, _utils__WEBPACK_IMPORTED_MODULE_4__.loadCustomFonts)(webFonts.filter((function(s) {
                            return !!s && isCustomFonts(s);
                        })));
                        loadGoogleFonts(webFonts.filter((function(s) {
                            return !!s && isGoogleFonts(s);
                        })));
                    }), 100);
                }));
                return _this;
            }
            _createClass(FontsList, [ {
                key: "fonts",
                get: function get() {
                    var _window$Lotta$customi2 = window.Lotta.customizer.settings, custom_fonts = _window$Lotta$customi2.custom_fonts, system_fonts = _window$Lotta$customi2.system_fonts, google_fonts = _window$Lotta$customi2.google_fonts;
                    var fonts = Object.keys(custom_fonts).concat(Object.keys(system_fonts), Object.keys(google_fonts));
                    var keyword = this.state.filter.toLowerCase();
                    if (this.state.filter) {
                        fonts = fonts.filter((function(f) {
                            if (custom_fonts[f] && custom_fonts[f].f.toLowerCase().indexOf(keyword) !== -1) {
                                return true;
                            }
                            if (system_fonts[f] && system_fonts[f].f.toLowerCase().indexOf(keyword) !== -1) {
                                return true;
                            }
                            if (google_fonts[f] && google_fonts[f].f.toLowerCase().indexOf(keyword) !== -1) {
                                return true;
                            }
                            return f.indexOf(keyword) !== -1;
                        }));
                    }
                    this.loadWebFonts(fonts);
                    return fonts;
                }
            }, {
                key: "componentDidMount",
                value: function componentDidMount() {
                    var _this2 = this;
                    setTimeout((function() {
                        if (_this2.listRef.current) {
                            var activeIndex = _this2.fonts.indexOf(_this2.props.family);
                            if (activeIndex !== -1) {
                                _this2.listRef.current.scrollToItem(activeIndex, "center");
                            }
                        }
                    }), 150);
                }
            }, {
                key: "render",
                value: function render() {
                    var _this3 = this;
                    if (!window.Lotta) {
                        return null;
                    }
                    var _window$Lotta$customi3 = window.Lotta.customizer.settings, custom_fonts = _window$Lotta$customi3.custom_fonts, system_fonts = _window$Lotta$customi3.system_fonts, google_fonts = _window$Lotta$customi3.google_fonts;
                    var data = Object.assign({}, custom_fonts, system_fonts, google_fonts);
                    var fonts = this.fonts;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                        className: "lotta-fonts-list-wrapper",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                            className: "lotta-fonts-search",
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("input", {
                                type: "text",
                                value: this.state.filter,
                                onChange: function onChange(e) {
                                    _this3.setState({
                                        filter: e.target.value
                                    });
                                }
                            })
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                            className: "lotta-fonts-list",
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(react_virtualized_auto_sizer__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                children: function children(_ref) {
                                    var height = _ref.height, width = _ref.width;
                                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(react_window__WEBPACK_IMPORTED_MODULE_6__.FixedSizeList, {
                                        ref: _this3.listRef,
                                        width,
                                        height,
                                        itemCount: fonts.length,
                                        itemSize: 65,
                                        itemData: {
                                            fonts,
                                            data
                                        },
                                        onScroll: function onScroll() {
                                            return _this3.loadWebFonts(fonts);
                                        },
                                        children: function children(props) {
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(SingleFont, _objectSpread({
                                                family: _this3.props.family,
                                                onClick: _this3.props.onChange
                                            }, props));
                                        }
                                    });
                                }
                            })
                        }) ]
                    });
                }
            } ]);
            return FontsList;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__.Component);
    }, (module, exports, __webpack_require__) => {
        var __WEBPACK_AMD_DEFINE_RESULT__;
        (function() {
            function aa(a, b, c) {
                return a.call.apply(a.bind, arguments);
            }
            function ba(a, b, c) {
                if (!a) throw Error();
                if (2 < arguments.length) {
                    var d = Array.prototype.slice.call(arguments, 2);
                    return function() {
                        var c = Array.prototype.slice.call(arguments);
                        Array.prototype.unshift.apply(c, d);
                        return a.apply(b, c);
                    };
                }
                return function() {
                    return a.apply(b, arguments);
                };
            }
            function p(a, b, c) {
                p = Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code") ? aa : ba;
                return p.apply(null, arguments);
            }
            var q = Date.now || function() {
                return +new Date;
            };
            function ca(a, b) {
                this.a = a;
                this.o = b || a;
                this.c = this.o.document;
            }
            var da = !!window.FontFace;
            function t(a, b, c, d) {
                b = a.c.createElement(b);
                if (c) for (var e in c) c.hasOwnProperty(e) && ("style" == e ? b.style.cssText = c[e] : b.setAttribute(e, c[e]));
                d && b.appendChild(a.c.createTextNode(d));
                return b;
            }
            function u(a, b, c) {
                a = a.c.getElementsByTagName(b)[0];
                a || (a = document.documentElement);
                a.insertBefore(c, a.lastChild);
            }
            function v(a) {
                a.parentNode && a.parentNode.removeChild(a);
            }
            function w(a, b, c) {
                b = b || [];
                c = c || [];
                for (var d = a.className.split(/\s+/), e = 0; e < b.length; e += 1) {
                    for (var f = !1, g = 0; g < d.length; g += 1) if (b[e] === d[g]) {
                        f = !0;
                        break;
                    }
                    f || d.push(b[e]);
                }
                b = [];
                for (e = 0; e < d.length; e += 1) {
                    f = !1;
                    for (g = 0; g < c.length; g += 1) if (d[e] === c[g]) {
                        f = !0;
                        break;
                    }
                    f || b.push(d[e]);
                }
                a.className = b.join(" ").replace(/\s+/g, " ").replace(/^\s+|\s+$/, "");
            }
            function y(a, b) {
                for (var c = a.className.split(/\s+/), d = 0, e = c.length; d < e; d++) if (c[d] == b) return !0;
                return !1;
            }
            function ea(a) {
                return a.o.location.hostname || a.a.location.hostname;
            }
            function z(a, b, c) {
                function d() {
                    m && e && f && (m(g), m = null);
                }
                b = t(a, "link", {
                    rel: "stylesheet",
                    href: b,
                    media: "all"
                });
                var e = !1, f = !0, g = null, m = c || null;
                da ? (b.onload = function() {
                    e = !0;
                    d();
                }, b.onerror = function() {
                    e = !0;
                    g = Error("Stylesheet failed to load");
                    d();
                }) : setTimeout((function() {
                    e = !0;
                    d();
                }), 0);
                u(a, "head", b);
            }
            function A(a, b, c, d) {
                var e = a.c.getElementsByTagName("head")[0];
                if (e) {
                    var f = t(a, "script", {
                        src: b
                    }), g = !1;
                    f.onload = f.onreadystatechange = function() {
                        g || this.readyState && "loaded" != this.readyState && "complete" != this.readyState || (g = !0, 
                        c && c(null), f.onload = f.onreadystatechange = null, "HEAD" == f.parentNode.tagName && e.removeChild(f));
                    };
                    e.appendChild(f);
                    setTimeout((function() {
                        g || (g = !0, c && c(Error("Script load timeout")));
                    }), d || 5e3);
                    return f;
                }
                return null;
            }
            function B() {
                this.a = 0;
                this.c = null;
            }
            function C(a) {
                a.a++;
                return function() {
                    a.a--;
                    D(a);
                };
            }
            function E(a, b) {
                a.c = b;
                D(a);
            }
            function D(a) {
                0 == a.a && a.c && (a.c(), a.c = null);
            }
            function F(a) {
                this.a = a || "-";
            }
            F.prototype.c = function(a) {
                for (var b = [], c = 0; c < arguments.length; c++) b.push(arguments[c].replace(/[\W_]+/g, "").toLowerCase());
                return b.join(this.a);
            };
            function G(a, b) {
                this.c = a;
                this.f = 4;
                this.a = "n";
                var c = (b || "n4").match(/^([nio])([1-9])$/i);
                c && (this.a = c[1], this.f = parseInt(c[2], 10));
            }
            function fa(a) {
                return H(a) + " " + (a.f + "00") + " 300px " + I(a.c);
            }
            function I(a) {
                var b = [];
                a = a.split(/,\s*/);
                for (var c = 0; c < a.length; c++) {
                    var d = a[c].replace(/['"]/g, "");
                    -1 != d.indexOf(" ") || /^\d/.test(d) ? b.push("'" + d + "'") : b.push(d);
                }
                return b.join(",");
            }
            function J(a) {
                return a.a + a.f;
            }
            function H(a) {
                var b = "normal";
                "o" === a.a ? b = "oblique" : "i" === a.a && (b = "italic");
                return b;
            }
            function ga(a) {
                var b = 4, c = "n", d = null;
                a && ((d = a.match(/(normal|oblique|italic)/i)) && d[1] && (c = d[1].substr(0, 1).toLowerCase()), 
                (d = a.match(/([1-9]00|normal|bold)/i)) && d[1] && (/bold/i.test(d[1]) ? b = 7 : /[1-9]00/.test(d[1]) && (b = parseInt(d[1].substr(0, 1), 10))));
                return c + b;
            }
            function ha(a, b) {
                this.c = a;
                this.f = a.o.document.documentElement;
                this.h = b;
                this.a = new F("-");
                this.j = !1 !== b.events;
                this.g = !1 !== b.classes;
            }
            function ia(a) {
                a.g && w(a.f, [ a.a.c("wf", "loading") ]);
                K(a, "loading");
            }
            function L(a) {
                if (a.g) {
                    var b = y(a.f, a.a.c("wf", "active")), c = [], d = [ a.a.c("wf", "loading") ];
                    b || c.push(a.a.c("wf", "inactive"));
                    w(a.f, c, d);
                }
                K(a, "inactive");
            }
            function K(a, b, c) {
                if (a.j && a.h[b]) if (c) a.h[b](c.c, J(c)); else a.h[b]();
            }
            function ja() {
                this.c = {};
            }
            function ka(a, b, c) {
                var d = [], e;
                for (e in b) if (b.hasOwnProperty(e)) {
                    var f = a.c[e];
                    f && d.push(f(b[e], c));
                }
                return d;
            }
            function M(a, b) {
                this.c = a;
                this.f = b;
                this.a = t(this.c, "span", {
                    "aria-hidden": "true"
                }, this.f);
            }
            function N(a) {
                u(a.c, "body", a.a);
            }
            function O(a) {
                return "display:block;position:absolute;top:-9999px;left:-9999px;font-size:300px;width:auto;height:auto;line-height:normal;margin:0;padding:0;font-variant:normal;white-space:nowrap;font-family:" + I(a.c) + ";" + ("font-style:" + H(a) + ";font-weight:" + (a.f + "00") + ";");
            }
            function P(a, b, c, d, e, f) {
                this.g = a;
                this.j = b;
                this.a = d;
                this.c = c;
                this.f = e || 3e3;
                this.h = f || void 0;
            }
            P.prototype.start = function() {
                var a = this.c.o.document, b = this, c = q(), d = new Promise((function(d, e) {
                    function f() {
                        q() - c >= b.f ? e() : a.fonts.load(fa(b.a), b.h).then((function(a) {
                            1 <= a.length ? d() : setTimeout(f, 25);
                        }), (function() {
                            e();
                        }));
                    }
                    f();
                })), e = null, f = new Promise((function(a, d) {
                    e = setTimeout(d, b.f);
                }));
                Promise.race([ f, d ]).then((function() {
                    e && (clearTimeout(e), e = null);
                    b.g(b.a);
                }), (function() {
                    b.j(b.a);
                }));
            };
            function Q(a, b, c, d, e, f, g) {
                this.v = a;
                this.B = b;
                this.c = c;
                this.a = d;
                this.s = g || "BESbswy";
                this.f = {};
                this.w = e || 3e3;
                this.u = f || null;
                this.m = this.j = this.h = this.g = null;
                this.g = new M(this.c, this.s);
                this.h = new M(this.c, this.s);
                this.j = new M(this.c, this.s);
                this.m = new M(this.c, this.s);
                a = new G(this.a.c + ",serif", J(this.a));
                a = O(a);
                this.g.a.style.cssText = a;
                a = new G(this.a.c + ",sans-serif", J(this.a));
                a = O(a);
                this.h.a.style.cssText = a;
                a = new G("serif", J(this.a));
                a = O(a);
                this.j.a.style.cssText = a;
                a = new G("sans-serif", J(this.a));
                a = O(a);
                this.m.a.style.cssText = a;
                N(this.g);
                N(this.h);
                N(this.j);
                N(this.m);
            }
            var R = {
                D: "serif",
                C: "sans-serif"
            }, S = null;
            function T() {
                if (null === S) {
                    var a = /AppleWebKit\/([0-9]+)(?:\.([0-9]+))/.exec(window.navigator.userAgent);
                    S = !!a && (536 > parseInt(a[1], 10) || 536 === parseInt(a[1], 10) && 11 >= parseInt(a[2], 10));
                }
                return S;
            }
            Q.prototype.start = function() {
                this.f.serif = this.j.a.offsetWidth;
                this.f["sans-serif"] = this.m.a.offsetWidth;
                this.A = q();
                U(this);
            };
            function la(a, b, c) {
                for (var d in R) if (R.hasOwnProperty(d) && b === a.f[R[d]] && c === a.f[R[d]]) return !0;
                return !1;
            }
            function U(a) {
                var b = a.g.a.offsetWidth, c = a.h.a.offsetWidth, d;
                (d = b === a.f.serif && c === a.f["sans-serif"]) || (d = T() && la(a, b, c));
                d ? q() - a.A >= a.w ? T() && la(a, b, c) && (null === a.u || a.u.hasOwnProperty(a.a.c)) ? V(a, a.v) : V(a, a.B) : ma(a) : V(a, a.v);
            }
            function ma(a) {
                setTimeout(p((function() {
                    U(this);
                }), a), 50);
            }
            function V(a, b) {
                setTimeout(p((function() {
                    v(this.g.a);
                    v(this.h.a);
                    v(this.j.a);
                    v(this.m.a);
                    b(this.a);
                }), a), 0);
            }
            function W(a, b, c) {
                this.c = a;
                this.a = b;
                this.f = 0;
                this.m = this.j = !1;
                this.s = c;
            }
            var X = null;
            W.prototype.g = function(a) {
                var b = this.a;
                b.g && w(b.f, [ b.a.c("wf", a.c, J(a).toString(), "active") ], [ b.a.c("wf", a.c, J(a).toString(), "loading"), b.a.c("wf", a.c, J(a).toString(), "inactive") ]);
                K(b, "fontactive", a);
                this.m = !0;
                na(this);
            };
            W.prototype.h = function(a) {
                var b = this.a;
                if (b.g) {
                    var c = y(b.f, b.a.c("wf", a.c, J(a).toString(), "active")), d = [], e = [ b.a.c("wf", a.c, J(a).toString(), "loading") ];
                    c || d.push(b.a.c("wf", a.c, J(a).toString(), "inactive"));
                    w(b.f, d, e);
                }
                K(b, "fontinactive", a);
                na(this);
            };
            function na(a) {
                0 == --a.f && a.j && (a.m ? (a = a.a, a.g && w(a.f, [ a.a.c("wf", "active") ], [ a.a.c("wf", "loading"), a.a.c("wf", "inactive") ]), 
                K(a, "active")) : L(a.a));
            }
            function oa(a) {
                this.j = a;
                this.a = new ja;
                this.h = 0;
                this.f = this.g = !0;
            }
            oa.prototype.load = function(a) {
                this.c = new ca(this.j, a.context || this.j);
                this.g = !1 !== a.events;
                this.f = !1 !== a.classes;
                pa(this, new ha(this.c, a), a);
            };
            function qa(a, b, c, d, e) {
                var f = 0 == --a.h;
                (a.f || a.g) && setTimeout((function() {
                    var a = e || null, m = d || null || {};
                    if (0 === c.length && f) L(b.a); else {
                        b.f += c.length;
                        f && (b.j = f);
                        var h, l = [];
                        for (h = 0; h < c.length; h++) {
                            var k = c[h], n = m[k.c], r = b.a, x = k;
                            r.g && w(r.f, [ r.a.c("wf", x.c, J(x).toString(), "loading") ]);
                            K(r, "fontloading", x);
                            r = null;
                            if (null === X) if (window.FontFace) {
                                var x = /Gecko.*Firefox\/(\d+)/.exec(window.navigator.userAgent), xa = /OS X.*Version\/10\..*Safari/.exec(window.navigator.userAgent) && /Apple/.exec(window.navigator.vendor);
                                X = x ? 42 < parseInt(x[1], 10) : xa ? !1 : !0;
                            } else X = !1;
                            X ? r = new P(p(b.g, b), p(b.h, b), b.c, k, b.s, n) : r = new Q(p(b.g, b), p(b.h, b), b.c, k, b.s, a, n);
                            l.push(r);
                        }
                        for (h = 0; h < l.length; h++) l[h].start();
                    }
                }), 0);
            }
            function pa(a, b, c) {
                var d = [], e = c.timeout;
                ia(b);
                var d = ka(a.a, c, a.c), f = new W(a.c, b, e);
                a.h = d.length;
                b = 0;
                for (c = d.length; b < c; b++) d[b].load((function(b, d, c) {
                    qa(a, f, b, d, c);
                }));
            }
            function ra(a, b) {
                this.c = a;
                this.a = b;
            }
            ra.prototype.load = function(a) {
                function b() {
                    if (f["__mti_fntLst" + d]) {
                        var c = f["__mti_fntLst" + d](), e = [], h;
                        if (c) for (var l = 0; l < c.length; l++) {
                            var k = c[l].fontfamily;
                            void 0 != c[l].fontStyle && void 0 != c[l].fontWeight ? (h = c[l].fontStyle + c[l].fontWeight, 
                            e.push(new G(k, h))) : e.push(new G(k));
                        }
                        a(e);
                    } else setTimeout((function() {
                        b();
                    }), 50);
                }
                var c = this, d = c.a.projectId, e = c.a.version;
                if (d) {
                    var f = c.c.o;
                    A(this.c, (c.a.api || "https://fast.fonts.net/jsapi") + "/" + d + ".js" + (e ? "?v=" + e : ""), (function(e) {
                        e ? a([]) : (f["__MonotypeConfiguration__" + d] = function() {
                            return c.a;
                        }, b());
                    })).id = "__MonotypeAPIScript__" + d;
                } else a([]);
            };
            function sa(a, b) {
                this.c = a;
                this.a = b;
            }
            sa.prototype.load = function(a) {
                var b, c, d = this.a.urls || [], e = this.a.families || [], f = this.a.testStrings || {}, g = new B;
                b = 0;
                for (c = d.length; b < c; b++) z(this.c, d[b], C(g));
                var m = [];
                b = 0;
                for (c = e.length; b < c; b++) if (d = e[b].split(":"), d[1]) for (var h = d[1].split(","), l = 0; l < h.length; l += 1) m.push(new G(d[0], h[l])); else m.push(new G(d[0]));
                E(g, (function() {
                    a(m, f);
                }));
            };
            function ta(a, b) {
                a ? this.c = a : this.c = ua;
                this.a = [];
                this.f = [];
                this.g = b || "";
            }
            var ua = "https://fonts.googleapis.com/css";
            function va(a, b) {
                for (var c = b.length, d = 0; d < c; d++) {
                    var e = b[d].split(":");
                    3 == e.length && a.f.push(e.pop());
                    var f = "";
                    2 == e.length && "" != e[1] && (f = ":");
                    a.a.push(e.join(f));
                }
            }
            function wa(a) {
                if (0 == a.a.length) throw Error("No fonts to load!");
                if (-1 != a.c.indexOf("kit=")) return a.c;
                for (var b = a.a.length, c = [], d = 0; d < b; d++) c.push(a.a[d].replace(/ /g, "+"));
                b = a.c + "?family=" + c.join("%7C");
                0 < a.f.length && (b += "&subset=" + a.f.join(","));
                0 < a.g.length && (b += "&text=" + encodeURIComponent(a.g));
                return b;
            }
            function ya(a) {
                this.f = a;
                this.a = [];
                this.c = {};
            }
            var za = {
                latin: "BESbswy",
                "latin-ext": "çöüğş",
                cyrillic: "йяЖ",
                greek: "αβΣ",
                khmer: "កខគ",
                Hanuman: "កខគ"
            }, Aa = {
                thin: "1",
                extralight: "2",
                "extra-light": "2",
                ultralight: "2",
                "ultra-light": "2",
                light: "3",
                regular: "4",
                book: "4",
                medium: "5",
                "semi-bold": "6",
                semibold: "6",
                "demi-bold": "6",
                demibold: "6",
                bold: "7",
                "extra-bold": "8",
                extrabold: "8",
                "ultra-bold": "8",
                ultrabold: "8",
                black: "9",
                heavy: "9",
                l: "3",
                r: "4",
                b: "7"
            }, Ba = {
                i: "i",
                italic: "i",
                n: "n",
                normal: "n"
            }, Ca = /^(thin|(?:(?:extra|ultra)-?)?light|regular|book|medium|(?:(?:semi|demi|extra|ultra)-?)?bold|black|heavy|l|r|b|[1-9]00)?(n|i|normal|italic)?$/;
            function Da(a) {
                for (var b = a.f.length, c = 0; c < b; c++) {
                    var d = a.f[c].split(":"), e = d[0].replace(/\+/g, " "), f = [ "n4" ];
                    if (2 <= d.length) {
                        var g;
                        var m = d[1];
                        g = [];
                        if (m) for (var m = m.split(","), h = m.length, l = 0; l < h; l++) {
                            var k;
                            k = m[l];
                            if (k.match(/^[\w-]+$/)) {
                                var n = Ca.exec(k.toLowerCase());
                                if (null == n) k = ""; else {
                                    k = n[2];
                                    k = null == k || "" == k ? "n" : Ba[k];
                                    n = n[1];
                                    if (null == n || "" == n) n = "4"; else var r = Aa[n], n = r ? r : isNaN(n) ? "4" : n.substr(0, 1);
                                    k = [ k, n ].join("");
                                }
                            } else k = "";
                            k && g.push(k);
                        }
                        0 < g.length && (f = g);
                        3 == d.length && (d = d[2], g = [], d = d ? d.split(",") : g, 0 < d.length && (d = za[d[0]]) && (a.c[e] = d));
                    }
                    a.c[e] || (d = za[e]) && (a.c[e] = d);
                    for (d = 0; d < f.length; d += 1) a.a.push(new G(e, f[d]));
                }
            }
            function Ea(a, b) {
                this.c = a;
                this.a = b;
            }
            var Fa = {
                Arimo: !0,
                Cousine: !0,
                Tinos: !0
            };
            Ea.prototype.load = function(a) {
                var b = new B, c = this.c, d = new ta(this.a.api, this.a.text), e = this.a.families;
                va(d, e);
                var f = new ya(e);
                Da(f);
                z(c, wa(d), C(b));
                E(b, (function() {
                    a(f.a, f.c, Fa);
                }));
            };
            function Ga(a, b) {
                this.c = a;
                this.a = b;
            }
            Ga.prototype.load = function(a) {
                var b = this.a.id, c = this.c.o;
                b ? A(this.c, (this.a.api || "https://use.typekit.net") + "/" + b + ".js", (function(b) {
                    if (b) a([]); else if (c.Typekit && c.Typekit.config && c.Typekit.config.fn) {
                        b = c.Typekit.config.fn;
                        for (var e = [], f = 0; f < b.length; f += 2) for (var g = b[f], m = b[f + 1], h = 0; h < m.length; h++) e.push(new G(g, m[h]));
                        try {
                            c.Typekit.load({
                                events: !1,
                                classes: !1,
                                async: !0
                            });
                        } catch (l) {}
                        a(e);
                    }
                }), 2e3) : a([]);
            };
            function Ha(a, b) {
                this.c = a;
                this.f = b;
                this.a = [];
            }
            Ha.prototype.load = function(a) {
                var b = this.f.id, c = this.c.o, d = this;
                b ? (c.__webfontfontdeckmodule__ || (c.__webfontfontdeckmodule__ = {}), c.__webfontfontdeckmodule__[b] = function(b, c) {
                    for (var g = 0, m = c.fonts.length; g < m; ++g) {
                        var h = c.fonts[g];
                        d.a.push(new G(h.name, ga("font-weight:" + h.weight + ";font-style:" + h.style)));
                    }
                    a(d.a);
                }, A(this.c, (this.f.api || "https://f.fontdeck.com/s/css/js/") + ea(this.c) + "/" + b + ".js", (function(b) {
                    b && a([]);
                }))) : a([]);
            };
            var Y = new oa(window);
            Y.a.c.custom = function(a, b) {
                return new sa(b, a);
            };
            Y.a.c.fontdeck = function(a, b) {
                return new Ha(b, a);
            };
            Y.a.c.monotype = function(a, b) {
                return new ra(b, a);
            };
            Y.a.c.typekit = function(a, b) {
                return new Ga(b, a);
            };
            Y.a.c.google = function(a, b) {
                return new Ea(b, a);
            };
            var Z = {
                load: p(Y.load, Y)
            };
            true ? !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
                return Z;
            }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : 0;
        })();
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12);
        var react__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
        var classCallCheck = function(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        };
        var createClass = function() {
            function defineProperties(target, props) {
                for (var i = 0; i < props.length; i++) {
                    var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true;
                    if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor);
                }
            }
            return function(Constructor, protoProps, staticProps) {
                if (protoProps) defineProperties(Constructor.prototype, protoProps);
                if (staticProps) defineProperties(Constructor, staticProps);
                return Constructor;
            };
        }();
        var _extends = Object.assign || 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;
        };
        var inherits = function(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    enumerable: false,
                    writable: true,
                    configurable: true
                }
            });
            if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
        };
        var possibleConstructorReturn = function(self, call) {
            if (!self) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return call && (typeof call === "object" || typeof call === "function") ? call : self;
        };
        var slicedToArray = function() {
            function sliceIterator(arr, i) {
                var _arr = [];
                var _n = true;
                var _d = false;
                var _e = undefined;
                try {
                    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                        _arr.push(_s.value);
                        if (i && _arr.length === i) break;
                    }
                } catch (err) {
                    _d = true;
                    _e = err;
                } finally {
                    try {
                        if (!_n && _i["return"]) _i["return"]();
                    } finally {
                        if (_d) throw _e;
                    }
                }
                return _arr;
            }
            return function(arr, i) {
                if (Array.isArray(arr)) {
                    return arr;
                } else if (Symbol.iterator in Object(arr)) {
                    return sliceIterator(arr, i);
                } else {
                    throw new TypeError("Invalid attempt to destructure non-iterable instance");
                }
            };
        }();
        var windowObject = void 0;
        if (typeof window !== "undefined") {
            windowObject = window;
        } else if (typeof self !== "undefined") {
            windowObject = self;
        } else {
            windowObject = __webpack_require__.g;
        }
        var cancelFrame = null;
        var requestFrame = null;
        var TIMEOUT_DURATION = 20;
        var clearTimeoutFn = windowObject.clearTimeout;
        var setTimeoutFn = windowObject.setTimeout;
        var cancelAnimationFrameFn = windowObject.cancelAnimationFrame || windowObject.mozCancelAnimationFrame || windowObject.webkitCancelAnimationFrame;
        var requestAnimationFrameFn = windowObject.requestAnimationFrame || windowObject.mozRequestAnimationFrame || windowObject.webkitRequestAnimationFrame;
        if (cancelAnimationFrameFn == null || requestAnimationFrameFn == null) {
            cancelFrame = clearTimeoutFn;
            requestFrame = function requestAnimationFrameViaSetTimeout(callback) {
                return setTimeoutFn(callback, TIMEOUT_DURATION);
            };
        } else {
            cancelFrame = function cancelFrame(_ref) {
                var _ref2 = slicedToArray(_ref, 2), animationFrameID = _ref2[0], timeoutID = _ref2[1];
                cancelAnimationFrameFn(animationFrameID);
                clearTimeoutFn(timeoutID);
            };
            requestFrame = function requestAnimationFrameWithSetTimeoutFallback(callback) {
                var animationFrameID = requestAnimationFrameFn((function animationFrameCallback() {
                    clearTimeoutFn(timeoutID);
                    callback();
                }));
                var timeoutID = setTimeoutFn((function timeoutCallback() {
                    cancelAnimationFrameFn(animationFrameID);
                    callback();
                }), TIMEOUT_DURATION);
                return [ animationFrameID, timeoutID ];
            };
        }
        function createDetectElementResize(nonce) {
            var animationKeyframes = void 0;
            var animationName = void 0;
            var animationStartEvent = void 0;
            var animationStyle = void 0;
            var checkTriggers = void 0;
            var resetTriggers = void 0;
            var scrollListener = void 0;
            var attachEvent = typeof document !== "undefined" && document.attachEvent;
            if (!attachEvent) {
                resetTriggers = function resetTriggers(element) {
                    var triggers = element.__resizeTriggers__, expand = triggers.firstElementChild, contract = triggers.lastElementChild, expandChild = expand.firstElementChild;
                    contract.scrollLeft = contract.scrollWidth;
                    contract.scrollTop = contract.scrollHeight;
                    expandChild.style.width = expand.offsetWidth + 1 + "px";
                    expandChild.style.height = expand.offsetHeight + 1 + "px";
                    expand.scrollLeft = expand.scrollWidth;
                    expand.scrollTop = expand.scrollHeight;
                };
                checkTriggers = function checkTriggers(element) {
                    return element.offsetWidth !== element.__resizeLast__.width || element.offsetHeight !== element.__resizeLast__.height;
                };
                scrollListener = function scrollListener(e) {
                    if (e.target.className && typeof e.target.className.indexOf === "function" && e.target.className.indexOf("contract-trigger") < 0 && e.target.className.indexOf("expand-trigger") < 0) {
                        return;
                    }
                    var element = this;
                    resetTriggers(this);
                    if (this.__resizeRAF__) {
                        cancelFrame(this.__resizeRAF__);
                    }
                    this.__resizeRAF__ = requestFrame((function animationFrame() {
                        if (checkTriggers(element)) {
                            element.__resizeLast__.width = element.offsetWidth;
                            element.__resizeLast__.height = element.offsetHeight;
                            element.__resizeListeners__.forEach((function forEachResizeListener(fn) {
                                fn.call(element, e);
                            }));
                        }
                    }));
                };
                var animation = false;
                var keyframeprefix = "";
                animationStartEvent = "animationstart";
                var domPrefixes = "Webkit Moz O ms".split(" ");
                var startEvents = "webkitAnimationStart animationstart oAnimationStart MSAnimationStart".split(" ");
                var pfx = "";
                {
                    var elm = document.createElement("fakeelement");
                    if (elm.style.animationName !== undefined) {
                        animation = true;
                    }
                    if (animation === false) {
                        for (var i = 0; i < domPrefixes.length; i++) {
                            if (elm.style[domPrefixes[i] + "AnimationName"] !== undefined) {
                                pfx = domPrefixes[i];
                                keyframeprefix = "-" + pfx.toLowerCase() + "-";
                                animationStartEvent = startEvents[i];
                                animation = true;
                                break;
                            }
                        }
                    }
                }
                animationName = "resizeanim";
                animationKeyframes = "@" + keyframeprefix + "keyframes " + animationName + " { from { opacity: 0; } to { opacity: 0; } } ";
                animationStyle = keyframeprefix + "animation: 1ms " + animationName + "; ";
            }
            var createStyles = function createStyles(doc) {
                if (!doc.getElementById("detectElementResize")) {
                    var css = (animationKeyframes ? animationKeyframes : "") + ".resize-triggers { " + (animationStyle ? animationStyle : "") + "visibility: hidden; opacity: 0; } " + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: " "; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; z-index: -1; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }', head = doc.head || doc.getElementsByTagName("head")[0], style = doc.createElement("style");
                    style.id = "detectElementResize";
                    style.type = "text/css";
                    if (nonce != null) {
                        style.setAttribute("nonce", nonce);
                    }
                    if (style.styleSheet) {
                        style.styleSheet.cssText = css;
                    } else {
                        style.appendChild(doc.createTextNode(css));
                    }
                    head.appendChild(style);
                }
            };
            var addResizeListener = function addResizeListener(element, fn) {
                if (attachEvent) {
                    element.attachEvent("onresize", fn);
                } else {
                    if (!element.__resizeTriggers__) {
                        var doc = element.ownerDocument;
                        var elementStyle = windowObject.getComputedStyle(element);
                        if (elementStyle && elementStyle.position === "static") {
                            element.style.position = "relative";
                        }
                        createStyles(doc);
                        element.__resizeLast__ = {};
                        element.__resizeListeners__ = [];
                        (element.__resizeTriggers__ = doc.createElement("div")).className = "resize-triggers";
                        var expandTrigger = doc.createElement("div");
                        expandTrigger.className = "expand-trigger";
                        expandTrigger.appendChild(doc.createElement("div"));
                        var contractTrigger = doc.createElement("div");
                        contractTrigger.className = "contract-trigger";
                        element.__resizeTriggers__.appendChild(expandTrigger);
                        element.__resizeTriggers__.appendChild(contractTrigger);
                        element.appendChild(element.__resizeTriggers__);
                        resetTriggers(element);
                        element.addEventListener("scroll", scrollListener, true);
                        if (animationStartEvent) {
                            element.__resizeTriggers__.__animationListener__ = function animationListener(e) {
                                if (e.animationName === animationName) {
                                    resetTriggers(element);
                                }
                            };
                            element.__resizeTriggers__.addEventListener(animationStartEvent, element.__resizeTriggers__.__animationListener__);
                        }
                    }
                    element.__resizeListeners__.push(fn);
                }
            };
            var removeResizeListener = function removeResizeListener(element, fn) {
                if (attachEvent) {
                    element.detachEvent("onresize", fn);
                } else {
                    element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
                    if (!element.__resizeListeners__.length) {
                        element.removeEventListener("scroll", scrollListener, true);
                        if (element.__resizeTriggers__.__animationListener__) {
                            element.__resizeTriggers__.removeEventListener(animationStartEvent, element.__resizeTriggers__.__animationListener__);
                            element.__resizeTriggers__.__animationListener__ = null;
                        }
                        try {
                            element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);
                        } catch (e) {}
                    }
                }
            };
            return {
                addResizeListener,
                removeResizeListener
            };
        }
        var AutoSizer = function(_React$PureComponent) {
            inherits(AutoSizer, _React$PureComponent);
            function AutoSizer() {
                var _ref;
                var _temp, _this, _ret;
                classCallCheck(this, AutoSizer);
                for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                return _ret = (_temp = (_this = possibleConstructorReturn(this, (_ref = AutoSizer.__proto__ || Object.getPrototypeOf(AutoSizer)).call.apply(_ref, [ this ].concat(args))), 
                _this), _this.state = {
                    height: _this.props.defaultHeight || 0,
                    width: _this.props.defaultWidth || 0
                }, _this._onResize = function() {
                    var _this$props = _this.props, disableHeight = _this$props.disableHeight, disableWidth = _this$props.disableWidth, onResize = _this$props.onResize;
                    if (_this._parentNode) {
                        var _height = _this._parentNode.offsetHeight || 0;
                        var _width = _this._parentNode.offsetWidth || 0;
                        var _style = window.getComputedStyle(_this._parentNode) || {};
                        var paddingLeft = parseInt(_style.paddingLeft, 10) || 0;
                        var paddingRight = parseInt(_style.paddingRight, 10) || 0;
                        var paddingTop = parseInt(_style.paddingTop, 10) || 0;
                        var paddingBottom = parseInt(_style.paddingBottom, 10) || 0;
                        var newHeight = _height - paddingTop - paddingBottom;
                        var newWidth = _width - paddingLeft - paddingRight;
                        if (!disableHeight && _this.state.height !== newHeight || !disableWidth && _this.state.width !== newWidth) {
                            _this.setState({
                                height: _height - paddingTop - paddingBottom,
                                width: _width - paddingLeft - paddingRight
                            });
                            onResize({
                                height: _height,
                                width: _width
                            });
                        }
                    }
                }, _this._setRef = function(autoSizer) {
                    _this._autoSizer = autoSizer;
                }, _temp), possibleConstructorReturn(_this, _ret);
            }
            createClass(AutoSizer, [ {
                key: "componentDidMount",
                value: function componentDidMount() {
                    var nonce = this.props.nonce;
                    if (this._autoSizer && this._autoSizer.parentNode && this._autoSizer.parentNode.ownerDocument && this._autoSizer.parentNode.ownerDocument.defaultView && this._autoSizer.parentNode instanceof this._autoSizer.parentNode.ownerDocument.defaultView.HTMLElement) {
                        this._parentNode = this._autoSizer.parentNode;
                        this._detectElementResize = createDetectElementResize(nonce);
                        this._detectElementResize.addResizeListener(this._parentNode, this._onResize);
                        this._onResize();
                    }
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    if (this._detectElementResize && this._parentNode) {
                        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);
                    }
                }
            }, {
                key: "render",
                value: function render() {
                    var _props = this.props, children = _props.children, className = _props.className, disableHeight = _props.disableHeight, disableWidth = _props.disableWidth, style = _props.style;
                    var _state = this.state, height = _state.height, width = _state.width;
                    var outerStyle = {
                        overflow: "visible"
                    };
                    var childParams = {};
                    var bailoutOnChildren = false;
                    if (!disableHeight) {
                        if (height === 0) {
                            bailoutOnChildren = true;
                        }
                        outerStyle.height = 0;
                        childParams.height = height;
                    }
                    if (!disableWidth) {
                        if (width === 0) {
                            bailoutOnChildren = true;
                        }
                        outerStyle.width = 0;
                        childParams.width = width;
                    }
                    return (0, react__WEBPACK_IMPORTED_MODULE_0__.createElement)("div", {
                        className,
                        ref: this._setRef,
                        style: _extends({}, outerStyle, style)
                    }, !bailoutOnChildren && children(childParams));
                }
            } ]);
            return AutoSizer;
        }(react__WEBPACK_IMPORTED_MODULE_0__.PureComponent);
        AutoSizer.defaultProps = {
            onResize: function onResize() {},
            disableHeight: false,
            disableWidth: false,
            style: {}
        };
        const __WEBPACK_DEFAULT_EXPORT__ = AutoSizer;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => VariantsList,
            getVariantName: () => getVariantName
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var getVariantName = function getVariantName(variant) {
            var allVariants = {
                inherit: "Default",
                100: "Thin 100",
                "100italic": "100 Italic",
                "100i": "100 Italic",
                200: "Extra-Light 200",
                "200italic": "200 Italic",
                "200i": "200 Italic",
                300: "Light 300",
                "300italic": "300 Italic",
                "300i": "300 Italic",
                400: "Normal 400",
                "400italic": "400 Italic",
                "400i": "400 Italic",
                500: "Medium 500",
                "500italic": "500 Italic",
                "500i": "500 Italic",
                600: "Semi-Bold 600",
                "600italic": "600 Italic",
                "600i": "600 Italic",
                700: "Bold 700",
                "700italic": "700 Italic",
                "700i": "700 Italic",
                800: "Extra-Bold 800",
                "800italic": "800 Italic",
                "800i": "800 Italic",
                900: "Ultra-Bold 900",
                "900italic": "900 Italic",
                "900i": "900 Italic"
            };
            return allVariants[variant] || variant;
        };
        var getVariants = function getVariants(family) {
            if (!window.Lotta) {
                return [];
            }
            var _window$Lotta$customi = window.Lotta.customizer.settings, custom_fonts = _window$Lotta$customi.custom_fonts, system_fonts = _window$Lotta$customi.system_fonts, google_fonts = _window$Lotta$customi.google_fonts;
            if (custom_fonts[family]) {
                return [ custom_fonts[family].v ];
            }
            if (system_fonts[family]) {
                return [ "300", "400", "700" ];
            }
            if (google_fonts[family]) {
                return google_fonts[family].v;
            }
            return [];
        };
        var VariantsList = function(_Component) {
            _inherits(VariantsList, _Component);
            var _super = _createSuper(VariantsList);
            function VariantsList() {
                _classCallCheck(this, VariantsList);
                return _super.apply(this, arguments);
            }
            _createClass(VariantsList, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, variant = _this$props.variant, family = _this$props.family, onChange = _this$props.onChange;
                    var variants = getVariants(family);
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                        className: "lotta-variants-list-wrapper",
                        children: variants.map((function(data, i) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                                className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("variant-item", {
                                    active: data === variant
                                }),
                                onClick: function onClick() {
                                    return onChange(data);
                                },
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                                    className: "variant-label",
                                    children: getVariantName(data)
                                })
                            }, i);
                        }))
                    });
                }
            } ]);
            return VariantsList;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _match_conditions__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(272);
        var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Condition = function(_Component) {
            _inherits(Condition, _Component);
            var _super = _createSuper(Condition);
            function Condition() {
                var _this;
                _classCallCheck(this, Condition);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "unbind", (function() {
                    return null;
                }));
                return _this;
            }
            _createClass(Condition, [ {
                key: "componentDidMount",
                value: function componentDidMount() {
                    var _this2 = this;
                    this.unbind = LottaEvents.bind("lotta-setting-change", (function(id) {
                        var conditions = Object.keys(_this2.props.options.condition);
                        if (conditions.indexOf(id) !== -1) {
                            _this2.forceUpdate();
                        }
                    }));
                    Object.keys(this.props.options.condition).forEach((function(setting) {
                        var control = wp.customize(setting);
                        if (control) {
                            control.bind((function() {
                                _this2.forceUpdate();
                            }));
                        }
                    }));
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    this.unbind();
                }
            }, {
                key: "render",
                value: function render() {
                    var _this3 = this;
                    var _this$props = this.props, options = _this$props.options, settings = _this$props.settings, _onChange = _this$props.onChange;
                    var czSettings = typeof settings === "function" ? settings() : settings;
                    czSettings = czSettings === _index__WEBPACK_IMPORTED_MODULE_1__.CZ_VALUES ? undefined : czSettings;
                    var values = Object.keys(options.condition).reduce((function(current, key) {
                        return _objectSpread(_objectSpread({}, current), {}, _defineProperty({}, key, czSettings ? czSettings[key] : wp.customize(key)()));
                    }), {});
                    var matches = (0, _match_conditions__WEBPACK_IMPORTED_MODULE_0__.matchValuesWithCondition)((0, 
                    _match_conditions__WEBPACK_IMPORTED_MODULE_0__.normalizeCondition)(options.condition), values);
                    matches = options.reverse ? !matches : matches;
                    return !matches ? (0, _index__WEBPACK_IMPORTED_MODULE_1__.buildNestedControls)({
                        controls: options.reverseControls,
                        settings,
                        onChange: function onChange(val, id) {
                            _onChange(val, id);
                        }
                    }) : (0, _index__WEBPACK_IMPORTED_MODULE_1__.buildNestedControls)({
                        controls: options.controls,
                        settings,
                        onChange: function onChange(val, id, self) {
                            _onChange(val, id);
                            if (!self) {
                                _this3.forceUpdate();
                            }
                        }
                    });
                }
            } ]);
            return Condition;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Condition;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _page_builder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(315);
        const __WEBPACK_DEFAULT_EXPORT__ = _page_builder__WEBPACK_IMPORTED_MODULE_0__["default"];
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _panel__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(178);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(254);
        var _sidebar__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(316);
        var _navigation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(319);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(279);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_5___default = __webpack_require__.n(immutability_helper__WEBPACK_IMPORTED_MODULE_5__);
        var _icons__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(277);
        var _throttler__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(75);
        var _customize__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(322);
        var _utils__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(4);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(10);
        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);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        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);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        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;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var PageBuilder = function(_Component) {
            _inherits(PageBuilder, _Component);
            var _super = _createSuper(PageBuilder);
            function PageBuilder() {
                var _this;
                _classCallCheck(this, PageBuilder);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    sidebarVisible: false,
                    sidebarType: "row-structure",
                    activeRow: null,
                    activeColumn: null
                });
                _defineProperty(_assertThisInitialized(_this), "renderSidebar", (function() {
                    return null;
                }));
                _defineProperty(_assertThisInitialized(_this), "openPanel", (function() {
                    return null;
                }));
                _defineProperty(_assertThisInitialized(_this), "columnsChangeThrottler", null);
                _defineProperty(_assertThisInitialized(_this), "elementsChangeThrottler", null);
                _defineProperty(_assertThisInitialized(_this), "handleChange", (function(id, settingId, val) {
                    if (!id) {
                        _this.props.onChange(val, settingId);
                        return;
                    }
                    if (id.startsWith("row")) {
                        var rowIndex = Number(id.replace("row-", "").split("-")[0]);
                        if (!isNaN(rowIndex)) {
                            if (Array.isArray(_this.props.value) && Array.isArray(_this.props.value[rowIndex]["settings"])) {
                                _this.props.value[rowIndex]["settings"] = {};
                            }
                            _this.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this.props.value), _defineProperty({}, rowIndex, {
                                settings: _defineProperty({}, settingId, {
                                    $set: val
                                })
                            })));
                        }
                    }
                    if (id.startsWith("col")) {
                        var indexes = id.replace("col-", "").split("-");
                        var _rowIndex = Number(indexes[0]);
                        var colIndex = Number(indexes[1]);
                        if (!isNaN(_rowIndex) && !isNaN(colIndex)) {
                            if (Array.isArray(_this.props.value) && Array.isArray(_this.props.value[_rowIndex]["columns"][colIndex]["settings"])) {
                                _this.props.value[_rowIndex]["columns"][colIndex]["settings"] = {};
                            }
                            _this.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this.props.value), _defineProperty({}, _rowIndex, {
                                columns: _defineProperty({}, colIndex, {
                                    settings: _defineProperty({}, settingId, {
                                        $set: val
                                    })
                                })
                            })));
                        }
                    }
                    if (id.startsWith("element")) {
                        var _indexes = id.replace("element-", "").split("-");
                        var _rowIndex2 = Number(_indexes[0]);
                        var _colIndex = Number(_indexes[1]);
                        var elIndex = Number(_indexes[2]);
                        if (!isNaN(_rowIndex2) && !isNaN(_colIndex) && !isNaN(elIndex)) {
                            if (Array.isArray(_this.props.value) && Array.isArray(_this.props.value[_rowIndex2]["columns"][_colIndex]["elements"][elIndex]["settings"])) {
                                _this.props.value[_rowIndex2]["columns"][_colIndex]["elements"][elIndex]["settings"] = {};
                            }
                            _this.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this.props.value), _defineProperty({}, _rowIndex2, {
                                columns: _defineProperty({}, _colIndex, {
                                    elements: _defineProperty({}, elIndex, {
                                        settings: _defineProperty({}, settingId, {
                                            $set: val
                                        })
                                    })
                                })
                            })));
                        }
                    }
                }));
                return _this;
            }
            _createClass(PageBuilder, [ {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    this.destroySidebars();
                }
            }, {
                key: "componentDidMount",
                value: function componentDidMount() {
                    var _this2 = this;
                    this.createSidebar();
                    (0, _customize__WEBPACK_IMPORTED_MODULE_8__.bindControlVisible)(this.props.id, (function(visible) {
                        if (!visible) {
                            _this2.setState({
                                sidebarVisible: false
                            }, (function() {
                                _this2.renderSidebar();
                            }));
                        }
                    }));
                }
            }, {
                key: "createSidebar",
                value: function createSidebar() {
                    var _this3 = this;
                    var container = document.createElement("div");
                    container.classList.add("lotta-page-builder-sidebar-wrapper");
                    document.querySelector(".wp-full-overlay").appendChild(container);
                    this.renderSidebar = function() {
                        var sidebarEl = (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_sidebar__WEBPACK_IMPORTED_MODULE_3__["default"], {
                            options: _this3.props.options,
                            type: _this3.state.sidebarType,
                            visible: _this3.state.sidebarVisible,
                            onClose: function onClose() {
                                _this3.setState({
                                    sidebarVisible: false
                                }, (function() {
                                    _this3.renderSidebar();
                                }));
                            },
                            onRowAdd: function onRowAdd(row) {
                                _this3.props.onChange([].concat(_toConsumableArray((0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this3.props.value)), [ row ]));
                            },
                            onElementChoose: function onElementChoose(el) {
                                if (_this3.state.activeRow === null || _this3.state.activeColumn === null) {
                                    return;
                                }
                                _this3.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                                _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this3.props.value), _defineProperty({}, _this3.state.activeRow, {
                                    columns: _defineProperty({}, _this3.state.activeColumn, {
                                        elements: {
                                            $push: [ {
                                                id: el,
                                                settings: {}
                                            } ]
                                        }
                                    })
                                })));
                            }
                        });
                        if (_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot) {
                            if (!_this3.sidebarRoot) {
                                _this3.sidebarRoot = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot)(container);
                            }
                            _this3.sidebarRoot.render(sidebarEl);
                        } else {
                            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.render)(sidebarEl, container);
                        }
                    };
                    this.renderSidebar();
                }
            }, {
                key: "destroySidebars",
                value: function destroySidebars() {
                    var _this4 = this;
                    var sidebars = document.querySelectorAll(".lotta-page-builder-sidebar-wrapper");
                    sidebars.forEach((function(sidebar) {
                        sidebar.classList.add("leave");
                    }));
                    setTimeout((function() {
                        if (_this4.sidebarRoot) {
                            _this4.sidebarRoot.unmout();
                            _this4.sidebarRoot = null;
                        } else {
                            sidebars.forEach((function(sidebar) {
                                (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.unmountComponentAtNode)(sidebar);
                                sidebar.remove();
                            }));
                        }
                    }), 150);
                }
            }, {
                key: "showRowStructureSidebar",
                value: function showRowStructureSidebar() {
                    var _this5 = this;
                    this.setState({
                        sidebarVisible: true,
                        sidebarType: "row-structure"
                    }, (function() {
                        _this5.renderSidebar();
                    }));
                }
            }, {
                key: "showElementsSidebar",
                value: function showElementsSidebar(row, col) {
                    var _this6 = this;
                    this.setState({
                        sidebarVisible: true,
                        sidebarType: "elements",
                        activeRow: row,
                        activeColumn: col
                    }, (function() {
                        _this6.renderSidebar();
                    }));
                }
            }, {
                key: "listeners",
                get: function get() {
                    var _this$props = this.props, value = _this$props.value, options = _this$props.options;
                    var listeners = {};
                    (0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(value).forEach((function(row, ri) {
                        listeners["row-".concat(ri)] = Object.assign({
                            id: "row-".concat(ri),
                            values: Object.assign({}, options.row.defaults, row.settings || {}),
                            label: "Row # ".concat(ri + 1)
                        }, options.row);
                        (0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(row.columns).forEach((function(col, ci) {
                            listeners["col-".concat(ri, "-").concat(ci)] = Object.assign({
                                id: "col-".concat(ri, "-").concat(ci),
                                values: Object.assign({}, options.column.defaults, col.settings || {}),
                                label: "Column # ".concat(ri + 1, "-").concat(ci + 1)
                            }, options.column);
                            (0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(col.elements).forEach((function(el, ei) {
                                var element = options.elements[el.id] || {};
                                listeners["element-".concat(ri, "-").concat(ci, "-").concat(ei)] = Object.assign({
                                    id: "element-".concat(ri, "-").concat(ci, "-").concat(ei),
                                    values: Object.assign({}, element.defaults, el.settings || {})
                                }, element);
                            }));
                        }));
                    }));
                    return listeners;
                }
            }, {
                key: "render",
                value: function render() {
                    var _this7 = this;
                    var options = this.props.options;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_panel__WEBPACK_IMPORTED_MODULE_1__["default"], {
                        listeners: this.listeners,
                        onChange: this.handleChange,
                        getSettings: function getSettings(id) {
                            if (id && _this7.listeners[id]) {
                                return _this7.listeners[id].values;
                            }
                            return undefined;
                        },
                        children: function children(_ref) {
                            var container = _ref.container, open = _ref.open;
                            _this7.openPanel = open;
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("div", {
                                ref: container,
                                className: "lotta-page-builder",
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsxs)("div", {
                                    className: "page-builder-content",
                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_navigation__WEBPACK_IMPORTED_MODULE_4__["default"], {
                                        options,
                                        value: (0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value),
                                        onRowsChange: function onRowsChange(rows) {
                                            _this7.props.onChange(rows);
                                        },
                                        onColumnsChange: function onColumnsChange(row, columns) {
                                            if (_this7.columnsChangeThrottler === null) {
                                                _this7.columnsChangeThrottler = new _throttler__WEBPACK_IMPORTED_MODULE_7__["default"](0, (function(changes) {
                                                    var value = (0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value);
                                                    changes.forEach((function(data) {
                                                        var _data = _slicedToArray(data, 2), row = _data[0], columns = _data[1];
                                                        value = immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()(value, _defineProperty({}, row, {
                                                            columns: {
                                                                $set: columns
                                                            }
                                                        }));
                                                    }));
                                                    _this7.props.onChange(value);
                                                }));
                                            }
                                            _this7.columnsChangeThrottler.buffer(row, columns);
                                        },
                                        onElementsChange: function onElementsChange(row, col, elements) {
                                            if (_this7.elementsChangeThrottler === null) {
                                                _this7.elementsChangeThrottler = new _throttler__WEBPACK_IMPORTED_MODULE_7__["default"](0, (function(changes) {
                                                    var value = (0, _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value);
                                                    changes.forEach((function(data) {
                                                        var _data2 = _slicedToArray(data, 3), row = _data2[0], col = _data2[1], elements = _data2[2];
                                                        value = immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()(value, _defineProperty({}, row, {
                                                            columns: _defineProperty({}, col, {
                                                                elements: {
                                                                    $set: elements
                                                                }
                                                            })
                                                        }));
                                                    }));
                                                    _this7.props.onChange(value);
                                                }));
                                            }
                                            _this7.elementsChangeThrottler.buffer(row, col, elements);
                                        },
                                        onRowRemove: function onRowRemove(row) {
                                            _this7.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value), {
                                                $splice: [ [ row, 1 ] ]
                                            }));
                                        },
                                        onColumnRemove: function onColumnRemove(row, col) {
                                            _this7.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value), _defineProperty({}, row, {
                                                columns: {
                                                    $splice: [ [ col, 1 ] ]
                                                }
                                            })));
                                        },
                                        onElementRemove: function onElementRemove(row, col, el) {
                                            _this7.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value), _defineProperty({}, row, {
                                                columns: _defineProperty({}, col, {
                                                    elements: {
                                                        $splice: [ [ el, 1 ] ]
                                                    }
                                                })
                                            })));
                                        },
                                        onColumnAdd: function onColumnAdd(row) {
                                            _this7.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_5___default()((0, 
                                            _utils__WEBPACK_IMPORTED_MODULE_9__.sanitize_array_value)(_this7.props.value), _defineProperty({}, row, {
                                                columns: {
                                                    $push: [ {
                                                        elements: [],
                                                        settings: {
                                                            width: "100%"
                                                        }
                                                    } ]
                                                }
                                            })));
                                        },
                                        onRowClick: function onRowClick(row) {
                                            open(_this7.listeners["row-".concat(row)]);
                                        },
                                        onColumnClick: function onColumnClick(row, col) {
                                            open(_this7.listeners["col-".concat(row, "-").concat(col)]);
                                        },
                                        onElementClick: function onElementClick(row, col, el) {
                                            open(_this7.listeners["element-".concat(row, "-").concat(col, "-").concat(el)]);
                                        },
                                        onAddElement: function onAddElement(row, col) {
                                            _this7.showElementsSidebar(row, col);
                                        }
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsxs)("button", {
                                        className: "page-builder-add-row",
                                        type: "button",
                                        onClick: function onClick() {
                                            return _this7.showRowStructureSidebar();
                                        },
                                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_6__.PlusSolid, {
                                            w: 14,
                                            h: 14
                                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("span", {
                                            children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Add Row")
                                        }) ]
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsxs)("button", {
                                        className: "page-builder-reset",
                                        type: "button",
                                        onClick: function onClick() {
                                            _this7.props.onChange(_this7.props.options["default"]);
                                        },
                                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_6__.RotateLeft, {
                                            w: 14,
                                            h: 14
                                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("span", {
                                            children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Reset Default")
                                        }) ]
                                    }) ]
                                })
                            });
                        }
                    });
                }
            } ]);
            return PageBuilder;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = PageBuilder;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(254);
        var _elements__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(317);
        var _row_structure__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(318);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var Sidebar = function(_Component) {
            _inherits(Sidebar, _Component);
            var _super = _createSuper(Sidebar);
            function Sidebar() {
                _classCallCheck(this, Sidebar);
                return _super.apply(this, arguments);
            }
            _createClass(Sidebar, [ {
                key: "render",
                value: function render() {
                    if (!this.props.visible) {
                        return null;
                    }
                    var _this$props = this.props, type = _this$props.type, options = _this$props.options, onClose = _this$props.onClose, onRowAdd = _this$props.onRowAdd, _onElementChoose = _this$props.onElementChoose;
                    var elements = type === "elements";
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                        className: "page-builder-sidebar",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                            className: "page-builder-sidebar-header",
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("span", {
                                className: "page-builder-sidebar-title",
                                children: elements ? (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("Choose Elements") : (0, 
                                _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)("Choose Row Structure")
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("button", {
                                type: "button",
                                onClick: onClose,
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("svg", {
                                    xmlns: "http://www.w3.org/2000/svg",
                                    viewBox: "0 0 512 512",
                                    width: 14,
                                    height: 14,
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("path", {
                                        d: "M175 175C184.4 165.7 199.6 165.7 208.1 175L255.1 222.1L303 175C312.4 165.7 327.6 165.7 336.1 175C346.3 184.4 346.3 199.6 336.1 208.1L289.9 255.1L336.1 303C346.3 312.4 346.3 327.6 336.1 336.1C327.6 346.3 312.4 346.3 303 336.1L255.1 289.9L208.1 336.1C199.6 346.3 184.4 346.3 175 336.1C165.7 327.6 165.7 312.4 175 303L222.1 255.1L175 208.1C165.7 199.6 165.7 184.4 175 175V175zM512 256C512 397.4 397.4 512 256 512C114.6 512 0 397.4 0 256C0 114.6 114.6 0 256 0C397.4 0 512 114.6 512 256zM256 48C141.1 48 48 141.1 48 256C48 370.9 141.1 464 256 464C370.9 464 464 370.9 464 256C464 141.1 370.9 48 256 48z"
                                    })
                                })
                            }) ]
                        }), elements ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_elements__WEBPACK_IMPORTED_MODULE_2__["default"], {
                            elements: options.elements,
                            onElementChoose: function onElementChoose(el) {
                                _onElementChoose(el);
                                onClose();
                            }
                        }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_row_structure__WEBPACK_IMPORTED_MODULE_3__["default"], {
                            onStructureChoose: function onStructureChoose(columns) {
                                columns = columns.map((function(column) {
                                    return {
                                        elements: [],
                                        settings: {
                                            width: {
                                                desktop: column,
                                                tablet: "100%",
                                                mobile: "100%"
                                            }
                                        }
                                    };
                                }));
                                onRowAdd({
                                    settings: {},
                                    columns
                                });
                                onClose();
                            }
                        }) ]
                    });
                }
            } ]);
            return Sidebar;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Sidebar;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _icons__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(277);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var Elements = function(_Component) {
            _inherits(Elements, _Component);
            var _super = _createSuper(Elements);
            function Elements() {
                _classCallCheck(this, Elements);
                return _super.apply(this, arguments);
            }
            _createClass(Elements, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, elements = _this$props.elements, onElementChoose = _this$props.onElementChoose;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                        className: "builder-elements",
                        children: Object.keys(elements).map((function(id) {
                            var icon = elements[id].icon;
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                                className: "builder-element-wrapper",
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)("div", {
                                    className: "builder-element",
                                    onClick: function onClick() {
                                        return onElementChoose(id);
                                    },
                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
                                        className: "element-icon",
                                        children: !icon ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.Cube, {}) : icon.indexOf("<svg") === -1 ? (0, 
                                        react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("img", {
                                            src: icon,
                                            alt: elements[id].label
                                        }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("span", {
                                            dangerouslySetInnerHTML: {
                                                __html: icon
                                            }
                                        })
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("span", {
                                        className: "element-label",
                                        children: elements[id].label
                                    }) ]
                                })
                            }, id);
                        }))
                    });
                }
            } ]);
            return Elements;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Elements;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var RowStructure = function(_Component) {
            _inherits(RowStructure, _Component);
            var _super = _createSuper(RowStructure);
            function RowStructure() {
                _classCallCheck(this, RowStructure);
                return _super.apply(this, arguments);
            }
            _createClass(RowStructure, [ {
                key: "render",
                value: function render() {
                    var onStructureChoose = this.props.onStructureChoose;
                    var structures = {
                        "structure-1": [ "100%" ],
                        "structure-2": [ "50%", "50%" ],
                        "structure-3": [ "33.33%", "33.33%", "33.33%" ],
                        "structure-4": [ "25%", "25%", "25%", "25%" ],
                        "structure-5": [ "30%", "70%" ],
                        "structure-6": [ "70%", "30%" ],
                        "structure-7": [ "25%", "25%", "50%" ],
                        "structure-8": [ "50%", "25%", "25%" ],
                        "structure-9": [ "25%", "50%", "25%" ],
                        "structure-10": [ "20%", "60%", "20%" ]
                    };
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("div", {
                        className: "row-structure-list",
                        children: Object.keys(structures).map((function(id) {
                            var columns = structures[id];
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("div", {
                                className: "row-structure-item",
                                onClick: function onClick() {
                                    onStructureChoose(columns);
                                },
                                children: columns.map((function(c, i) {
                                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("span", {
                                        style: {
                                            width: c
                                        },
                                        className: "row-structure-column"
                                    }, i);
                                }))
                            }, id);
                        }))
                    });
                }
            } ]);
            return RowStructure;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = RowStructure;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _navigation_row__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(320);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_2__);
        var deep_equal__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_3__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var Navigation = function(_Component) {
            _inherits(Navigation, _Component);
            var _super = _createSuper(Navigation);
            function Navigation() {
                _classCallCheck(this, Navigation);
                return _super.apply(this, arguments);
            }
            _createClass(Navigation, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, value = _this$props.value, options = _this$props.options, onRowClick = _this$props.onRowClick, onColumnClick = _this$props.onColumnClick, onColumnAdd = _this$props.onColumnAdd, onElementClick = _this$props.onElementClick, onAddElement = _this$props.onAddElement, onRowRemove = _this$props.onRowRemove, onColumnRemove = _this$props.onColumnRemove, onElementRemove = _this$props.onElementRemove, onRowsChange = _this$props.onRowsChange, onColumnsChange = _this$props.onColumnsChange, onElementsChange = _this$props.onElementsChange;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_2__.ReactSortable, {
                        list: value,
                        className: "page-builder-rows",
                        group: "page-builder-rows",
                        setList: function setList(newRows) {
                            if (deep_equal__WEBPACK_IMPORTED_MODULE_3___default()(newRows, value)) {
                                return;
                            }
                            onRowsChange(newRows);
                        },
                        children: value.map((function(row, i) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_navigation_row__WEBPACK_IMPORTED_MODULE_1__["default"], {
                                index: i,
                                options,
                                data: row,
                                onRowClick,
                                onColumnClick,
                                onColumnAdd,
                                onElementClick,
                                onAddElement,
                                onRowRemove,
                                onColumnRemove,
                                onElementRemove,
                                onColumnsChange,
                                onElementsChange
                            }, i);
                        }))
                    });
                }
            } ]);
            return Navigation;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Navigation;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _icons__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(277);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(254);
        var _navigation_column__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(321);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_4___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_4__);
        var deep_equal__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_5___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_5__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var NavigationRow = function(_Component) {
            _inherits(NavigationRow, _Component);
            var _super = _createSuper(NavigationRow);
            function NavigationRow() {
                var _this;
                _classCallCheck(this, NavigationRow);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    collapse: false
                });
                return _this;
            }
            _createClass(NavigationRow, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, index = _this$props.index, data = _this$props.data, options = _this$props.options, onRowClick = _this$props.onRowClick, onRowRemove = _this$props.onRowRemove, _onColumnClick = _this$props.onColumnClick, onColumnAdd = _this$props.onColumnAdd, _onColumnRemove = _this$props.onColumnRemove, _onElementClick = _this$props.onElementClick, _onAddElement = _this$props.onAddElement, _onElementRemove = _this$props.onElementRemove, onColumnsChange = _this$props.onColumnsChange, _onElementsChange = _this$props.onElementsChange;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                        className: "page-builder-row-container",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                            className: "page-builder-row",
                            onClick: function onClick() {
                                return onRowClick(index);
                            },
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("button", {
                                    type: "button",
                                    onClick: function onClick(ev) {
                                        ev.stopPropagation();
                                        _this2.setState({
                                            collapse: !_this2.state.collapse
                                        });
                                    },
                                    children: this.state.collapse ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.RightCaret, {}) : (0, 
                                    react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.DownCaret, {})
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.Row, {}), (0, 
                                react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("span", {
                                    children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Row")
                                }) ]
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsxs)("div", {
                                className: "page-builder-actions",
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("button", {
                                    type: "button",
                                    onClick: function onClick(ev) {
                                        ev.stopPropagation();
                                        onColumnAdd(index);
                                    },
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.Plus, {})
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("button", {
                                    type: "button",
                                    className: "remove",
                                    onClick: function onClick(ev) {
                                        ev.stopPropagation();
                                        onRowRemove(index);
                                    },
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.CircleXMark, {})
                                }) ]
                            }) ]
                        }), !this.state.collapse && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_4__.ReactSortable, {
                            className: "page-builder-columns",
                            group: "page-builder-columns",
                            list: data.columns,
                            setList: function setList(newColumns) {
                                if (deep_equal__WEBPACK_IMPORTED_MODULE_5___default()(newColumns, data.columns)) {
                                    return;
                                }
                                onColumnsChange(index, newColumns);
                            },
                            children: data.columns.map((function(col, i) {
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_navigation_column__WEBPACK_IMPORTED_MODULE_3__["default"], {
                                    index: i,
                                    options,
                                    data: col,
                                    onElementsChange: function onElementsChange(colIndex, elements) {
                                        _onElementsChange(index, colIndex, elements);
                                    },
                                    onElementClick: function onElementClick(colIndex, elIndex) {
                                        _onElementClick(index, colIndex, elIndex);
                                    },
                                    onColumnClick: function onColumnClick(colIndex) {
                                        _onColumnClick(index, colIndex);
                                    },
                                    onColumnRemove: function onColumnRemove(colIndex) {
                                        _onColumnRemove(index, colIndex);
                                    },
                                    onAddElement: function onAddElement(colIndex) {
                                        _onAddElement(index, colIndex);
                                    },
                                    onElementRemove: function onElementRemove(colIndex, elIndex) {
                                        _onElementRemove(index, colIndex, elIndex);
                                    }
                                }, i);
                            }))
                        }) ]
                    });
                }
            } ]);
            return NavigationRow;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = NavigationRow;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _icons__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(277);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(254);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_3___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_3__);
        var deep_equal__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_4___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_4__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var NavigationColumn = function(_Component) {
            _inherits(NavigationColumn, _Component);
            var _super = _createSuper(NavigationColumn);
            function NavigationColumn() {
                var _this;
                _classCallCheck(this, NavigationColumn);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    collapse: false
                });
                return _this;
            }
            _createClass(NavigationColumn, [ {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, index = _this$props.index, options = _this$props.options, data = _this$props.data, onColumnClick = _this$props.onColumnClick, onColumnRemove = _this$props.onColumnRemove, onElementClick = _this$props.onElementClick, onAddElement = _this$props.onAddElement, onElementRemove = _this$props.onElementRemove, onElementsChange = _this$props.onElementsChange;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                        className: "page-builder-row-container",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                            className: "page-builder-column",
                            onClick: function onClick() {
                                return onColumnClick(index);
                            },
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                    type: "button",
                                    onClick: function onClick(ev) {
                                        ev.stopPropagation();
                                        _this2.setState({
                                            collapse: !_this2.state.collapse
                                        });
                                    },
                                    children: this.state.collapse ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.RightCaret, {}) : (0, 
                                    react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.DownCaret, {})
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.Column, {}), (0, 
                                react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                    children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Column")
                                }) ]
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                className: "page-builder-actions",
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                    type: "button",
                                    onClick: function onClick(ev) {
                                        ev.stopPropagation();
                                        onAddElement(index);
                                    },
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.Plus, {})
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                    type: "button",
                                    className: "remove",
                                    onClick: function onClick(ev) {
                                        ev.stopPropagation();
                                        onColumnRemove(index);
                                    },
                                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.CircleXMark, {})
                                }) ]
                            }) ]
                        }), !this.state.collapse && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_3__.ReactSortable, {
                            list: data.elements,
                            className: "page-builder-elements",
                            group: "page-builder-elements",
                            setList: function setList(newElements) {
                                if (deep_equal__WEBPACK_IMPORTED_MODULE_4___default()(data.elements, newElements)) {
                                    return;
                                }
                                onElementsChange(index, newElements);
                            },
                            children: data.elements.map((function(el, i) {
                                var element = options.elements[el.id] || {};
                                var label = element.label || (el.id || (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Element")).replace(/./, (function(s) {
                                    return s.toUpperCase();
                                })).replace(/\_|\-/g, " ");
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                    className: "page-builder-element",
                                    onClick: function onClick() {
                                        onElementClick(index, i);
                                    },
                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                        children: [ !element.icon ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.Cube, {}) : element.icon.indexOf("<svg") === -1 ? (0, 
                                        react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("img", {
                                            width: 14,
                                            height: 14,
                                            src: element.icon,
                                            alt: element.label
                                        }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                                            className: "page-builder-element-icon",
                                            dangerouslySetInnerHTML: {
                                                __html: element.icon
                                            }
                                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                            children: label
                                        }) ]
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                                        className: "page-builder-actions",
                                        children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                            type: "button",
                                            className: "remove",
                                            onClick: function onClick(ev) {
                                                ev.stopPropagation();
                                                onElementRemove(index, i);
                                            },
                                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_1__.CircleXMark, {})
                                        })
                                    }) ]
                                }, i);
                            }))
                        }) ]
                    });
                }
            } ]);
            return NavigationColumn;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = NavigationColumn;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            bindControlVisible: () => bindControlVisible
        });
        function bindControlVisible(id, callback) {
            var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function() {
                return null;
            };
            var $body = jQuery("body");
            var handleBind = function handleBind() {
                var control = wp.customize.control(id);
                if (!control || !control.section()) {
                    return fallback();
                }
                var section = wp.customize.section(control.section());
                if (!section) {
                    return fallback();
                }
                section.expanded.bind(callback);
            };
            if ($body.hasClass("wp-customizer") && $body.hasClass("ready")) {
                return handleBind();
            }
            wp.customize.bind("ready", handleBind);
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _builder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(324);
        const __WEBPACK_DEFAULT_EXPORT__ = _builder__WEBPACK_IMPORTED_MODULE_0__.Builder;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            Builder: () => Builder
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _placements__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(325);
        var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(327);
        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
        var clsx__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9);
        var _panel__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(178);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_6___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_6__);
        var _throttler__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(75);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(279);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_8___default = __webpack_require__.n(immutability_helper__WEBPACK_IMPORTED_MODULE_8__);
        var _customize__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(322);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(10);
        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);
        }
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Builder = function(_Component) {
            _inherits(Builder, _Component);
            var _super = _createSuper(Builder);
            function Builder() {
                var _this;
                _classCallCheck(this, Builder);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    visible: true,
                    device: wp.customize && wp.customize.previewedDevice ? wp.customize.previewedDevice() : "desktop"
                });
                _defineProperty(_assertThisInitialized(_this), "listener", (function() {
                    return _this.setState({
                        device: wp.customize && wp.customize.previewedDevice ? wp.customize.previewedDevice() : "desktop"
                    }, (function() {
                        return _this.renderPlacements();
                    }));
                }));
                _defineProperty(_assertThisInitialized(_this), "elementsChangeThrottler", null);
                _defineProperty(_assertThisInitialized(_this), "renderPlacements", (function() {
                    return null;
                }));
                _defineProperty(_assertThisInitialized(_this), "openPanel", (function() {
                    return null;
                }));
                return _this;
            }
            _createClass(Builder, [ {
                key: "bindDeviceListener",
                value: function bindDeviceListener() {
                    var _this2 = this;
                    if (!this.props.options.responsive_builder) return;
                    if (!wp.customize) return;
                    setTimeout((function() {
                        return wp.customize.previewedDevice.bind(_this2.listener);
                    }), 1e3);
                }
            }, {
                key: "unbindDeviceListener",
                value: function unbindDeviceListener() {
                    if (!this.props.options.responsive_builder) return;
                    if (!wp.customize) return;
                    wp.customize.previewedDevice.unbind(this.listener);
                }
            }, {
                key: "setDevice",
                value: function setDevice(device) {
                    var _this3 = this;
                    this.setState({
                        device
                    }, (function() {
                        return _this3.renderPlacements();
                    }));
                    wp.customize && wp.customize.previewedDevice.set(device);
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    this.unbindDeviceListener();
                    this.destroyPlacements();
                }
            }, {
                key: "componentDidMount",
                value: function componentDidMount() {
                    var _this4 = this;
                    this.bindDeviceListener();
                    (0, _customize__WEBPACK_IMPORTED_MODULE_9__.bindControlVisible)(this.props.id, (function(visible) {
                        visible ? _this4.createPlacements() : _this4.destroyPlacements();
                    }), (function() {
                        _this4.createPlacements();
                    }));
                }
            }, {
                key: "destroyPlacements",
                value: function destroyPlacements() {
                    var _this5 = this;
                    var placements = document.querySelectorAll(".lotta-builder-placements-wrapper");
                    placements.forEach((function(placement) {
                        placement.classList.add("leave");
                    }));
                    setTimeout((function() {
                        if (_this5.placementsRoot) {
                            _this5.placementsRoot.unmount();
                            _this5.placementsRoot = null;
                        } else {
                            placements.forEach((function(placement) {
                                (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.unmountComponentAtNode)(placement);
                                placement.remove();
                            }));
                        }
                    }), 150);
                }
            }, {
                key: "createPlacements",
                value: function createPlacements() {
                    var _this6 = this;
                    var container = document.createElement("div");
                    container.classList.add("lotta-builder-placements-wrapper");
                    document.querySelector(".wp-full-overlay").appendChild(container);
                    this.renderPlacements = function() {
                        var responsive = _this6.props.options.responsive_builder;
                        var device = _this6.state.device === "desktop" ? "desktop" : "mobile";
                        var placementsEl = (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_placements__WEBPACK_IMPORTED_MODULE_1__["default"], {
                            value: _this6.props.value,
                            elements: _this6.props.options.elements,
                            rows: _this6.props.options.rows,
                            device,
                            onDeviceChange: _this6.setDevice.bind(_this6),
                            responsive,
                            onElementsChange: function onElementsChange(row, col, elements) {
                                if (!_this6.elementsChangeThrottler) {
                                    _this6.elementsChangeThrottler = new _throttler__WEBPACK_IMPORTED_MODULE_7__["default"](0, (function(changes) {
                                        var device = _this6.state.device === "desktop" ? "desktop" : "mobile";
                                        var value = (0, _utils__WEBPACK_IMPORTED_MODULE_2__.ensureBuilderValueStructure)(responsive, _this6.props.value, _this6.props.options.rows);
                                        changes.forEach((function(data) {
                                            var _data = _slicedToArray(data, 3), row = _data[0], col = _data[1], elements = _data[2];
                                            var rowData = _this6.props.options.rows[row] || {};
                                            var defaultColumn = rowData.type === "off-canvas" ? {
                                                elements: [],
                                                settings: {
                                                    direction: "column"
                                                }
                                            } : {
                                                elements: [],
                                                settings: {}
                                            };
                                            if (responsive) {
                                                if (!value[row][device]["columns"][col]) {
                                                    value[row][device]["columns"][col] = defaultColumn;
                                                }
                                                value[row][device]["columns"][col]["elements"] = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.array_unique)(elements);
                                            } else {
                                                if (!value[row]["columns"][col]) {
                                                    value[row]["columns"][col] = defaultColumn;
                                                }
                                                value[row]["columns"][col]["elements"] = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.array_unique)(elements);
                                            }
                                        }));
                                        _this6.props.onChange(value);
                                        _this6.setState({}, _this6.renderPlacements);
                                    }));
                                }
                                _this6.elementsChangeThrottler.buffer(row, col, elements);
                            },
                            onElementRemove: function onElementRemove(el, row, col) {
                                var value = (0, _utils__WEBPACK_IMPORTED_MODULE_2__.ensureBuilderValueStructure)(responsive, _this6.props.value, _this6.props.options.rows);
                                if (responsive) {
                                    var index = value[row][device]["columns"][col]["elements"].indexOf(el);
                                    if (index !== -1) {
                                        value[row][device]["columns"][col]["elements"].splice(index, 1);
                                    }
                                } else {
                                    var _index = value[row]["columns"][col]["elements"].indexOf(el);
                                    if (_index !== -1) {
                                        value[row]["columns"][col]["elements"].splice(_index, 1);
                                    }
                                }
                                _this6.props.onChange(value);
                                _this6.setState({}, _this6.renderPlacements);
                            },
                            onElementClick: function onElementClick(el) {
                                _this6.openPanel(_this6.props.options.elements[el]);
                            },
                            onRowClick: function onRowClick(row) {
                                _this6.openPanel(_this6.props.options.rows[row]);
                            },
                            onSettingColumn: function onSettingColumn(row, colIndex) {
                                var device = responsive ? _this6.state.device === "desktop" ? "desktop" : "mobile" : "all";
                                _this6.openPanel(_this6.listeners["".concat(row, "-").concat(device, "-").concat(colIndex)]);
                            },
                            onAddColumn: function onAddColumn(row, colIndex) {
                                var value = (0, _utils__WEBPACK_IMPORTED_MODULE_2__.ensureBuilderValueStructure)(responsive, _this6.props.value, _this6.props.options.rows);
                                if (responsive) {
                                    var columns = value[row][device]["columns"];
                                    value[row][device]["columns"] = [].concat(_toConsumableArray(columns.splice(0, colIndex + 1)), [ {
                                        elements: [],
                                        settings: {}
                                    } ], _toConsumableArray(columns.splice(colIndex, columns.length)));
                                } else {
                                    var _columns = value[row]["columns"];
                                    value[row]["columns"] = [].concat(_toConsumableArray(_columns.splice(0, colIndex + 1)), [ {
                                        elements: [],
                                        settings: {}
                                    } ], _toConsumableArray(_columns.splice(colIndex, _columns.length)));
                                }
                                _this6.props.onChange(value);
                                _this6.setState({}, _this6.renderPlacements);
                            },
                            onRemoveColumn: function onRemoveColumn(row, colIndex) {
                                var value = (0, _utils__WEBPACK_IMPORTED_MODULE_2__.ensureBuilderValueStructure)(responsive, _this6.props.value, _this6.props.options.rows);
                                if (responsive) {
                                    value[row][device]["columns"].splice(colIndex, 1);
                                } else {
                                    value[row]["columns"].splice(colIndex, 1);
                                }
                                _this6.props.onChange(value);
                                _this6.setState({}, _this6.renderPlacements);
                            }
                        });
                        if (_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot) {
                            if (!_this6.placementsRoot) {
                                _this6.placementsRoot = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRoot)(container);
                            }
                            _this6.placementsRoot.render(placementsEl);
                        } else {
                            (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.render)(placementsEl, container);
                        }
                    };
                    this.renderPlacements();
                }
            }, {
                key: "listeners",
                get: function get() {
                    var _this$props$options = this.props.options, elements = _this$props$options.elements, rows = _this$props$options.rows, column = _this$props$options.column, responsive_builder = _this$props$options.responsive_builder;
                    var value = this.props.value;
                    var listeners = Object.assign({}, elements, rows);
                    Object.keys(value).forEach((function(row) {
                        var responsiveValue = responsive_builder ? value[row] : {
                            all: value[row]
                        };
                        Object.keys(responsiveValue).forEach((function(device) {
                            var columns = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.sanitize_array_value)(responsiveValue[device].columns);
                            columns.forEach((function(col, ci) {
                                listeners[row + "-" + device + "-" + ci] = Object.assign({
                                    id: row + "-" + device + "-" + ci,
                                    values: Object.assign({}, column.defaults, col.settings || {}),
                                    label: rows[row].label + " #".concat(ci + 1, " - ").concat(device.replace(/./, (function(s) {
                                        return s.toUpperCase();
                                    })))
                                }, column);
                            }));
                        }));
                    }));
                    return listeners;
                }
            }, {
                key: "render",
                value: function render() {
                    var _this7 = this;
                    var _this$props$options2 = this.props.options, elements = _this$props$options2.elements, responsive_builder = _this$props$options2.responsive_builder;
                    var value = this.props.value;
                    var currentDevice = this.state.device === "desktop" ? "desktop" : "mobile";
                    var chosen = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.array_flat)(responsive_builder ? Object.values(value).map((function(v) {
                        return v[currentDevice];
                    })) : Object.values(value));
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(_panel__WEBPACK_IMPORTED_MODULE_5__["default"], {
                        listeners: this.listeners,
                        onChange: function onChange(id, settingId, val) {
                            if (!id) {
                                _this7.props.onChange(val, settingId);
                                return;
                            }
                            var indexes = id.split("-");
                            var row = indexes[0];
                            var device = indexes[1];
                            var col = Number(indexes[2]);
                            if (device === "all") {
                                if (Array.isArray(_this7.props.value[row]["columns"][col]["settings"])) {
                                    _this7.props.value[row]["columns"][col]["settings"] = {};
                                }
                                _this7.props.onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_8___default()(_this7.props.value, _defineProperty({}, row, {
                                    columns: _defineProperty({}, col, {
                                        settings: _defineProperty({}, settingId, {
                                            $set: val
                                        })
                                    })
                                })));
                            } else {
                                if (Array.isArray(_this7.props.value[row][device]["columns"][col]["settings"])) {
                                    _this7.props.value[row][device]["columns"][col]["settings"] = {};
                                }
                                var newValue = immutability_helper__WEBPACK_IMPORTED_MODULE_8___default()(_this7.props.value, _defineProperty({}, row, _defineProperty({}, device, {
                                    columns: _defineProperty({}, col, {
                                        settings: _defineProperty({}, settingId, {
                                            $set: val
                                        })
                                    })
                                })));
                                _this7.props.onChange(newValue);
                            }
                        },
                        getSettings: function getSettings(id) {
                            if (id && _this7.listeners[id]) {
                                return _this7.listeners[id].values;
                            }
                            return undefined;
                        },
                        children: function children(_ref) {
                            var container = _ref.container, open = _ref.open;
                            _this7.openPanel = open;
                            var sortableElements = Object.keys(elements).map((function(e) {
                                if (elements[e].device && elements[e].device !== currentDevice) {
                                    return null;
                                }
                                return {
                                    id: e
                                };
                            })).filter((function(e) {
                                return e !== null;
                            }));
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("div", {
                                ref: container,
                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_6__.ReactSortable, {
                                    list: sortableElements,
                                    setList: function setList() {
                                        return null;
                                    },
                                    filter: ".inactive",
                                    group: {
                                        name: "builder-item",
                                        pull: "clone",
                                        put: false
                                    },
                                    className: "lotta-builder-elements",
                                    children: sortableElements.map((function(e) {
                                        return e.id;
                                    })).map((function(key) {
                                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsxs)("div", {
                                            "data-id": key,
                                            onClick: function onClick() {
                                                return (0, _utils__WEBPACK_IMPORTED_MODULE_3__.in_array)(key, chosen) ? open(elements[key]) : null;
                                            },
                                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_4__["default"])("lotta-builder-element", {
                                                inactive: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.in_array)(key, chosen),
                                                active: !(0, _utils__WEBPACK_IMPORTED_MODULE_3__.in_array)(key, chosen)
                                            }),
                                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("span", {
                                                children: elements[key].label || (0, _utils__WEBPACK_IMPORTED_MODULE_3__.capitalize)(key)
                                            }), (0, _utils__WEBPACK_IMPORTED_MODULE_3__.in_array)(key, chosen) ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("span", {
                                                className: "lotta-dashicon dashicons-arrow-right-alt2"
                                            }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_10__.jsx)("span", {
                                                className: "lotta-dashicon dashicons-move"
                                            }) ]
                                        }, key);
                                    }))
                                })
                            });
                        }
                    });
                }
            } ]);
            return Builder;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => Placements
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var _react_spring_web__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(180);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(254);
        var clsx__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9);
        var _placement_row__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(326);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Placements = function(_Component) {
            _inherits(Placements, _Component);
            var _super = _createSuper(Placements);
            function Placements() {
                var _this;
                _classCallCheck(this, Placements);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "state", {
                    visible: true
                });
                _defineProperty(_assertThisInitialized(_this), "placements", (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createRef)());
                _defineProperty(_assertThisInitialized(_this), "toggleVisible", (function() {
                    _this.setState({
                        visible: !_this.state.visible
                    }, (function() {
                        _this.updatePreviewBottom();
                    }));
                }));
                return _this;
            }
            _createClass(Placements, [ {
                key: "componentDidMount",
                value: function componentDidMount() {
                    this.updatePreviewBottom();
                }
            }, {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                    this.updatePreviewBottom(true);
                }
            }, {
                key: "updatePreviewBottom",
                value: function updatePreviewBottom() {
                    var reset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
                    var preview = document.querySelector(".wp-full-overlay #customize-preview");
                    if (!preview) {
                        return;
                    }
                    if (reset) {
                        preview.style.bottom = 0;
                        return;
                    }
                    if (!this.placements.current) {
                        return;
                    }
                    preview.style.bottom = this.placements.current.offsetHeight + "px";
                }
            }, {
                key: "render",
                value: function render() {
                    var _this2 = this;
                    var _this$props = this.props, rows = _this$props.rows, elements = _this$props.elements, value = _this$props.value, responsive = _this$props.responsive, device = _this$props.device, onDeviceChange = _this$props.onDeviceChange, onRowClick = _this$props.onRowClick, onAddColumn = _this$props.onAddColumn, onSettingColumn = _this$props.onSettingColumn, onRemoveColumn = _this$props.onRemoveColumn, onElementsChange = _this$props.onElementsChange, onElementRemove = _this$props.onElementRemove, onElementClick = _this$props.onElementClick;
                    var offCanvas = {};
                    var normalRows = {};
                    Object.keys(rows).forEach((function(id) {
                        if (rows[id].device && rows[id].device !== device) {
                            return;
                        }
                        if (rows[id].type === "off-canvas") {
                            offCanvas[id] = rows[id];
                        } else {
                            normalRows[id] = rows[id];
                        }
                    }));
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_react_spring_web__WEBPACK_IMPORTED_MODULE_1__.Transition, {
                        items: null,
                        from: {
                            transform: "translateY(100%)"
                        },
                        enter: {
                            transform: "translateY(0)"
                        },
                        leave: {
                            transform: "translateY(100%)"
                        },
                        config: function config(item, type) {
                            return {
                                delay: 0,
                                duration: 120
                            };
                        },
                        children: function children(props) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)(_react_spring_web__WEBPACK_IMPORTED_MODULE_1__.animated.div, {
                                ref: _this2.placements,
                                style: props,
                                className: "lotta-builder-placements",
                                children: [ _this2.state.visible && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                    className: "builder-placements-wrapper",
                                    children: [ Object.keys(offCanvas).length > 0 && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                                        className: "builder-off-canvas-area",
                                        children: Object.keys(offCanvas).map((function(key) {
                                            var row = rows[key];
                                            var rowData = value ? value[key] || {} : {};
                                            var _ref = responsive && rowData[device] ? rowData[device] : rowData, columns = _ref.columns;
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_placement_row__WEBPACK_IMPORTED_MODULE_4__["default"], {
                                                id: key,
                                                row,
                                                columns,
                                                elements,
                                                onClick: onRowClick,
                                                onAddColumn,
                                                onSettingColumn,
                                                onRemoveColumn,
                                                onElementsChange,
                                                onElementClick,
                                                onElementRemove
                                            }, key);
                                        }))
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                                        className: "builder-rows-area",
                                        children: Object.keys(normalRows).map((function(key) {
                                            var row = rows[key];
                                            var rowData = value ? value[key] || {} : {};
                                            var _ref2 = responsive && rowData[device] ? rowData[device] : rowData, columns = _ref2.columns;
                                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_placement_row__WEBPACK_IMPORTED_MODULE_4__["default"], {
                                                id: key,
                                                row,
                                                columns,
                                                elements,
                                                onClick: onRowClick,
                                                onAddColumn,
                                                onSettingColumn,
                                                onRemoveColumn,
                                                onElementsChange,
                                                onElementClick,
                                                onElementRemove
                                            }, key);
                                        }))
                                    }) ]
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                    className: "builder-footer",
                                    children: [ responsive && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("ul", {
                                        className: "builder-responsive-controls",
                                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("li", {
                                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_3__["default"])({
                                                active: device === "desktop"
                                            }),
                                            onClick: function onClick() {
                                                return onDeviceChange("desktop");
                                            },
                                            children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Desktop Builder")
                                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("li", {
                                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_3__["default"])({
                                                active: device !== "desktop"
                                            }),
                                            onClick: function onClick() {
                                                return onDeviceChange("tablet");
                                            },
                                            children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Tablet / Mobile Builder")
                                        }) ]
                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("button", {
                                        className: "toggle",
                                        type: "button",
                                        onClick: _this2.toggleVisible,
                                        children: [ _this2.state.visible ? (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                            className: "lotta-dashicon dashicons-arrow-down-alt2"
                                        }) : (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                            className: "lotta-dashicon dashicons-arrow-up-alt2"
                                        }), (_this2.state.visible ? (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Hidden") : (0, 
                                        _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Show")) + " " + (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Builder") ]
                                    }) ]
                                }) ]
                            });
                        }
                    });
                }
            } ]);
            return Placements;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => PlacementRow
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_1__);
        var deep_equal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_2__);
        var _icons__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(277);
        var _utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var PlacementRow = function(_Component) {
            _inherits(PlacementRow, _Component);
            var _super = _createSuper(PlacementRow);
            function PlacementRow() {
                _classCallCheck(this, PlacementRow);
                return _super.apply(this, arguments);
            }
            _createClass(PlacementRow, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, id = _this$props.id, row = _this$props.row, columns = _this$props.columns, elements = _this$props.elements, _onClick = _this$props.onClick, onAddColumn = _this$props.onAddColumn, onSettingColumn = _this$props.onSettingColumn, onRemoveColumn = _this$props.onRemoveColumn, onElementsChange = _this$props.onElementsChange, onElementClick = _this$props.onElementClick, onElementRemove = _this$props.onElementRemove;
                    var isOffCanvas = row.type === "off-canvas";
                    var showColumns = columns;
                    if (!Array.isArray(showColumns) || showColumns.length === 0) {
                        showColumns = isOffCanvas ? [ {
                            elements: [],
                            settings: {
                                direction: "column"
                            }
                        } ] : [ {
                            elements: [],
                            settings: {}
                        } ];
                    }
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                        className: "builder-row",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                            className: "builder-row-actions",
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("button", {
                                disabled: row.controls.length <= 0,
                                type: "button",
                                onClick: function onClick() {
                                    return _onClick(id);
                                },
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                    className: "lotta-dashicon dashicons-admin-generic mr-4"
                                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                    children: row.label
                                }) ]
                            })
                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                            className: "builder-columns",
                            children: showColumns.map((function(column, colIndex) {
                                var columnItems = (0, _utils__WEBPACK_IMPORTED_MODULE_4__.sanitize_array_value)(column.elements);
                                var sortableItems = columnItems.map((function(i) {
                                    return {
                                        id: i
                                    };
                                }));
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                    className: "builder-column",
                                    style: {
                                        width: Math.floor(1 / showColumns.length * 100 * 100) / 100 + "%"
                                    },
                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                        className: "builder-column-content",
                                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_1__.ReactSortable, {
                                            list: sortableItems,
                                            group: "builder-item",
                                            className: "builder-sortable-items",
                                            setList: function setList(newItems) {
                                                if (deep_equal__WEBPACK_IMPORTED_MODULE_2___default()(newItems, sortableItems)) {
                                                    return;
                                                }
                                                onElementsChange(id, colIndex, newItems.map((function(item) {
                                                    return item.id;
                                                })));
                                            },
                                            children: columnItems.map((function(item) {
                                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                                    "data-id": item,
                                                    className: "builder-item",
                                                    onClick: function onClick() {
                                                        return onElementClick(item);
                                                    },
                                                    children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                                        children: (elements[item] || {}).label
                                                    }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                                        className: "lotta-dashicon dashicons-no-alt",
                                                        onClick: function onClick(ev) {
                                                            ev.stopPropagation();
                                                            onElementRemove(item, id, colIndex);
                                                        }
                                                    }) ]
                                                }, item);
                                            }))
                                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("div", {
                                            className: "builder-column-actions",
                                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                                type: "button",
                                                onClick: function onClick() {
                                                    return onSettingColumn(id, colIndex);
                                                },
                                                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("span", {
                                                    className: "lotta-dashicon dashicons-admin-generic"
                                                })
                                            })
                                        }) ]
                                    }), !isOffCanvas && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsxs)("div", {
                                        className: "builder-change-columns",
                                        children: [ showColumns.length < row.maxColumns && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                            className: "builder-add-column",
                                            type: "button",
                                            onClick: function onClick() {
                                                return onAddColumn(id, colIndex);
                                            },
                                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_3__.PlusSolid, {})
                                        }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)("button", {
                                            className: "builder-remove-column",
                                            type: "button",
                                            onClick: function onClick() {
                                                return onRemoveColumn(id, colIndex);
                                            },
                                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_5__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_3__.CircleXMark, {})
                                        }) ]
                                    }) ]
                                }, colIndex);
                            }))
                        }) ]
                    });
                }
            } ]);
            return PlacementRow;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            ensureBuilderValueStructure: () => ensureBuilderValueStructure,
            ensureRowValueStructure: () => ensureRowValueStructure
        });
        var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
        function _toConsumableArray(arr) {
            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
        }
        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.");
        }
        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);
        }
        function _iterableToArray(iter) {
            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
        }
        function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
        }
        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;
        }
        function sanitizeRowData(value) {
            var columns = (0, _utils__WEBPACK_IMPORTED_MODULE_0__.sanitize_array_value)(value.columns);
            var newColumns = [];
            columns.forEach((function(col) {
                newColumns.push({
                    elements: _toConsumableArray((0, _utils__WEBPACK_IMPORTED_MODULE_0__.sanitize_array_value)(col.elements)),
                    settings: JSON.parse(JSON.stringify(col.settings || {}))
                });
            }));
            return {
                columns: newColumns
            };
        }
        function ensureRowValueStructure(responsive, value) {
            if (responsive) {
                return {
                    desktop: sanitizeRowData(value.desktop || {}),
                    mobile: sanitizeRowData(value.mobile || {})
                };
            }
            return sanitizeRowData(value);
        }
        function ensureBuilderValueStructure(responsive, value, rows) {
            var newValue = {};
            for (var id in rows) {
                newValue[id] = ensureRowValueStructure(responsive, value[id] || {});
            }
            return newValue;
        }
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(280);
        var react_sortablejs__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(react_sortablejs__WEBPACK_IMPORTED_MODULE_1__);
        var deep_equal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14);
        var deep_equal__WEBPACK_IMPORTED_MODULE_2___default = __webpack_require__.n(deep_equal__WEBPACK_IMPORTED_MODULE_2__);
        var _layers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(278);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(279);
        var immutability_helper__WEBPACK_IMPORTED_MODULE_4___default = __webpack_require__.n(immutability_helper__WEBPACK_IMPORTED_MODULE_4__);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(254);
        var _icons__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(277);
        var underscore__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(70);
        var underscore__WEBPACK_IMPORTED_MODULE_7___default = __webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_7__);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(10);
        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);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var Repeater = function(_Component) {
            _inherits(Repeater, _Component);
            var _super = _createSuper(Repeater);
            function Repeater() {
                _classCallCheck(this, Repeater);
                return _super.apply(this, arguments);
            }
            _createClass(Repeater, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, value = _this$props.value, options = _this$props.options, _onChange = _this$props.onChange;
                    var title_field = options.title_field, controls = options.controls, defaultSettings = options.defaultSettings, limit = options.limit, empty = options.empty, limitLabel = options.limitLabel;
                    var items = limit ? (value || []).slice(0, limit) : value || [];
                    var titleTemplate = underscore__WEBPACK_IMPORTED_MODULE_7___default().template(title_field || "Item #<%= index %>");
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsxs)("div", {
                        className: "lotta-repeater",
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(react_sortablejs__WEBPACK_IMPORTED_MODULE_1__.ReactSortable, {
                            tag: "ul",
                            className: "lotta-layers",
                            handle: ".layer-label",
                            list: items,
                            setList: function setList(newItems) {
                                if (deep_equal__WEBPACK_IMPORTED_MODULE_2___default()(newItems, items)) {
                                    return;
                                }
                                _onChange(newItems);
                            },
                            children: items.map((function(item, index) {
                                item.id = index;
                                var layer = {
                                    label: titleTemplate({
                                        index,
                                        settings: item.settings
                                    }),
                                    controls
                                };
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(_layers__WEBPACK_IMPORTED_MODULE_3__.Layer, {
                                    value: item,
                                    dynamic: empty || items.length > 1,
                                    settings: Object.assign({}, defaultSettings, item.settings),
                                    layer,
                                    onNestedChange: function onNestedChange(val, id) {
                                        _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_4___default()(items, _defineProperty({}, index, {
                                            settings: _defineProperty({}, id, {
                                                $set: val
                                            })
                                        })));
                                    },
                                    onRemove: function onRemove() {
                                        if (!empty && items.length <= 1) {
                                            return;
                                        }
                                        _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_4___default()(items, {
                                            $splice: [ [ index, 1 ] ]
                                        }));
                                    },
                                    onChange: function onChange(newItem) {
                                        _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_4___default()(items, _defineProperty({}, index, {
                                            $set: newItem
                                        })));
                                    }
                                }, index);
                            }))
                        }), (!limit || items.length < limit) && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsxs)("button", {
                            className: "repeater-add-element",
                            type: "button",
                            onClick: function onClick() {
                                _onChange(immutability_helper__WEBPACK_IMPORTED_MODULE_4___default()(items, {
                                    $push: [ {
                                        visible: true,
                                        settings: defaultSettings
                                    } ]
                                }));
                            },
                            children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)(_icons__WEBPACK_IMPORTED_MODULE_6__.PlusSolid, {
                                w: 14,
                                h: 14
                            }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("span", {
                                children: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)("Add Item")
                            }) ]
                        }), !(limit && items.length < limit) && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_8__.jsx)("div", {
                            className: "lotta-info lotta-info-align-center",
                            dangerouslySetInnerHTML: {
                                __html: limitLabel
                            }
                        }) ]
                    });
                }
            } ]);
            return Repeater;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = Repeater;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(190);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_1___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__);
        var clsx__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _slicedToArray(arr, i) {
            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
        }
        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.");
        }
        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);
        }
        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;
        }
        function _iterableToArrayLimit(arr, i) {
            var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
            if (_i == null) return;
            var _arr = [];
            var _n = true;
            var _d = false;
            var _s, _e;
            try {
                for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"] != null) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
        }
        function IconsLibrary(_ref) {
            var active = _ref.active, libraries = _ref.libraries, current = _ref.current, onChoose = _ref.onChoose;
            var allLibraries = window.Lotta.customizer.iconsLibrary;
            libraries = libraries ? libraries : Object.keys(allLibraries);
            active = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.in_array)(active, libraries) ? active : libraries[0];
            var _useState = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_1__.useState)(active), _useState2 = _slicedToArray(_useState, 2), activeLib = _useState2[0], setActiveLib = _useState2[1];
            var _useState3 = (0, _wordpress_element__WEBPACK_IMPORTED_MODULE_1__.useState)(""), _useState4 = _slicedToArray(_useState3, 2), keyword = _useState4[0], setKeyword = _useState4[1];
            var activeIcons = allLibraries[activeLib].icons;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("div", {
                className: "lotta-icons-modal",
                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("ul", {
                    className: "lotta-modal-tabs",
                    children: libraries.map((function(libName) {
                        var lib = allLibraries[libName];
                        if (!lib) return;
                        var label = lib.label ? lib.label : libName.replace(/./, (function(s) {
                            return s.toUpperCase();
                        })).replace(/\_|\-/g, " ");
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("li", {
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])({
                                active: libName === activeLib
                            }),
                            onClick: function onClick() {
                                return setActiveLib(libName);
                            },
                            children: label
                        }, libName);
                    }))
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("div", {
                    className: "icons-filter",
                    children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("input", {
                        type: "text",
                        onChange: function onChange(e) {
                            setKeyword(e.target.value);
                        }
                    })
                }), (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("div", {
                    className: "lotta-icons-modal-content",
                    children: Object.keys(activeIcons).map((function(icon) {
                        if (keyword && icon.indexOf(keyword) == -1) {
                            return null;
                        }
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("span", {
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])("lotta-icon-preview", {
                                active: activeIcons[icon].value === current
                            }),
                            onClick: function onClick() {
                                onChoose({
                                    value: activeIcons[icon].value,
                                    library: activeLib
                                });
                            },
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("i", {
                                className: activeIcons[icon].value
                            })
                        }, icon);
                    }))
                }) ]
            });
        }
        function Icons(_ref2) {
            var value = _ref2.value, options = _ref2.options, onChange = _ref2.onChange;
            var libraries = options.libraries;
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("div", {
                className: "lotta-icons",
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_0__["default"], {
                    placement: "bottom",
                    content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(IconsLibrary, {
                        active: value.library,
                        current: value.value,
                        libraries,
                        onChoose: onChange
                    }),
                    children: function children(_ref3) {
                        var props = _ref3.props, isOpen = _ref3.isOpen;
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("span", _objectSpread(_objectSpread({}, props), {}, {
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_2__["default"])("lotta-icon-preview", {
                                active: isOpen
                            }),
                            children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("i", {
                                className: value.value
                            })
                        }));
                    }
                })
            });
        }
        const __WEBPACK_DEFAULT_EXPORT__ = Icons;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        var CheckboxSelect = function(_Component) {
            _inherits(CheckboxSelect, _Component);
            var _super = _createSuper(CheckboxSelect);
            function CheckboxSelect() {
                _classCallCheck(this, CheckboxSelect);
                return _super.apply(this, arguments);
            }
            _createClass(CheckboxSelect, [ {
                key: "render",
                value: function render() {
                    var _this$props = this.props, options = _this$props.options, value = _this$props.value, onChoice = _this$props.onChoice;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", _objectSpread(_objectSpread({
                        className: "lotta-multi-select"
                    }, options.attr || {}), {}, {
                        children: Object.keys(options.choices).map((function(choice) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)("label", {
                                children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("input", {
                                    type: "checkbox",
                                    checked: value[choice] !== undefined && value[choice] === "yes",
                                    onChange: function onChange() {
                                        return onChoice(choice);
                                    }
                                }), options.choices[choice] ]
                            }, choice);
                        }))
                    }));
                }
            } ]);
            return CheckboxSelect;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var ButtonsGroupSelect = function(_Component2) {
            _inherits(ButtonsGroupSelect, _Component2);
            var _super2 = _createSuper(ButtonsGroupSelect);
            function ButtonsGroupSelect() {
                _classCallCheck(this, ButtonsGroupSelect);
                return _super2.apply(this, arguments);
            }
            _createClass(ButtonsGroupSelect, [ {
                key: "render",
                value: function render() {
                    var _this$props2 = this.props, options = _this$props2.options, value = _this$props2.value, onChoice = _this$props2.onChoice;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("ul", _objectSpread(_objectSpread({
                        className: "lotta-multi-select lotta-buttons-group lotta-solid-buttons"
                    }, options.attr || {}), {}, {
                        children: Object.keys(options.choices).map((function(choice) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("li", {
                                className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])({
                                    active: value[choice] !== undefined && value[choice] === "yes"
                                }),
                                onClick: function onClick() {
                                    onChoice(choice);
                                },
                                dangerouslySetInnerHTML: {
                                    __html: options.choices[choice]
                                }
                            }, choice);
                        }))
                    }));
                }
            } ]);
            return ButtonsGroupSelect;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        var MultiSelect = function MultiSelect(props) {
            var options = props.options, value = props.value, onChange = props.onChange;
            var handleChange = function handleChange(c) {
                onChange(_objectSpread(_objectSpread({}, value), {}, _defineProperty({}, c, value[c] !== undefined && value[c] === "yes" ? "no" : "yes")));
            };
            if (options.view === "buttons") {
                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(ButtonsGroupSelect, _objectSpread(_objectSpread({}, props), {}, {
                    onChoice: handleChange
                }));
            }
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(CheckboxSelect, _objectSpread(_objectSpread({}, props), {}, {
                onChoice: handleChange
            }));
        };
        const __WEBPACK_DEFAULT_EXPORT__ = MultiSelect;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _components_state_popup__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(190);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(254);
        var _toggle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(176);
        var _slider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(174);
        var _index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(10);
        function ownKeys(object, enumerableOnly) {
            var keys = Object.keys(object);
            if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                enumerableOnly && (symbols = symbols.filter((function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                }))), keys.push.apply(keys, symbols);
            }
            return keys;
        }
        function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = null != arguments[i] ? arguments[i] : {};
                i % 2 ? ownKeys(Object(source), !0).forEach((function(key) {
                    _defineProperty(target, key, source[key]);
                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                }));
            }
            return target;
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var Filters = function Filters(props) {
            var value = props.value, _onChange = props.onChange;
            var sections = [ {
                id: "enable",
                component: _toggle__WEBPACK_IMPORTED_MODULE_3__["default"],
                params: {
                    default: "no"
                },
                options: {
                    design: "inline",
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Enable")
                }
            }, {
                id: "blur",
                component: _slider__WEBPACK_IMPORTED_MODULE_4__["default"],
                params: {
                    default: 0
                },
                options: {
                    wrapperAttr: {
                        className: "blur"
                    },
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Blur"),
                    min: 0,
                    max: 10,
                    decimals: 1,
                    defaultUnit: false
                }
            }, {
                id: "contrast",
                component: _slider__WEBPACK_IMPORTED_MODULE_4__["default"],
                params: {
                    default: 100
                },
                options: {
                    wrapperAttr: {
                        className: "contrast"
                    },
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Contrast"),
                    min: 0,
                    max: 200,
                    defaultUnit: false
                }
            }, {
                id: "brightness",
                component: _slider__WEBPACK_IMPORTED_MODULE_4__["default"],
                params: {
                    default: 100
                },
                options: {
                    wrapperAttr: {
                        className: "brightness"
                    },
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Brightness"),
                    min: 0,
                    max: 200,
                    defaultUnit: false
                }
            }, {
                id: "saturate",
                component: _slider__WEBPACK_IMPORTED_MODULE_4__["default"],
                params: {
                    default: 100
                },
                options: {
                    wrapperAttr: {
                        className: "saturate"
                    },
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Saturate"),
                    min: 0,
                    max: 200,
                    defaultUnit: false
                }
            }, {
                id: "hue",
                component: _slider__WEBPACK_IMPORTED_MODULE_4__["default"],
                params: {
                    default: 0
                },
                options: {
                    wrapperAttr: {
                        className: "hue"
                    },
                    label: (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Hue"),
                    min: 0,
                    max: 360,
                    defaultUnit: false
                }
            } ];
            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                className: "lotta-css-filter",
                children: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)(_components_state_popup__WEBPACK_IMPORTED_MODULE_0__["default"], {
                    placement: "bottom",
                    content: (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                        className: "css-filter-modal",
                        children: sections.map((function(s) {
                            return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", {
                                className: "css-filter-section",
                                children: (0, _index__WEBPACK_IMPORTED_MODULE_5__.buildControl)({
                                    params: s.params,
                                    options: s.options,
                                    value: value[s.id] !== undefined ? value[s.id] : s.params["default"],
                                    Component: s.component,
                                    onChange: function onChange(v) {
                                        _onChange(_objectSpread(_objectSpread({}, value), {}, _defineProperty({}, s.id, v)));
                                    }
                                })
                            }, s.id);
                        }))
                    }),
                    children: function children(_ref) {
                        var _clsx;
                        var props = _ref.props, isOpen = _ref.isOpen;
                        return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_6__.jsx)("div", _objectSpread(_objectSpread({
                            className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("lotta-modal-value", (_clsx = {}, 
                            _defineProperty(_clsx, "lotta-modal-value-active", isOpen), _defineProperty(_clsx, "lotta-disabled", value.enable !== "yes"), 
                            _clsx))
                        }, props), {}, {
                            children: value.enable === "yes" ? (0, _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("Adjust") : (0, 
                            _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__.__)("None")
                        }));
                    }
                })
            });
        };
        Filters.renderingConfig = {
            design: "inline"
        };
        const __WEBPACK_DEFAULT_EXPORT__ = Filters;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
        __webpack_require__.d(__webpack_exports__, {
            default: () => __WEBPACK_DEFAULT_EXPORT__
        });
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
        var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
        var clsx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
        var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
        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);
        }
        function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
            }
        }
        function _defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }
        function _createClass(Constructor, protoProps, staticProps) {
            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
            if (staticProps) _defineProperties(Constructor, staticProps);
            Object.defineProperty(Constructor, "prototype", {
                writable: false
            });
            return Constructor;
        }
        function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
            }
            subClass.prototype = Object.create(superClass && superClass.prototype, {
                constructor: {
                    value: subClass,
                    writable: true,
                    configurable: true
                }
            });
            Object.defineProperty(subClass, "prototype", {
                writable: false
            });
            if (superClass) _setPrototypeOf(subClass, superClass);
        }
        function _setPrototypeOf(o, p) {
            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
            };
            return _setPrototypeOf(o, p);
        }
        function _createSuper(Derived) {
            var hasNativeReflectConstruct = _isNativeReflectConstruct();
            return function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                    var NewTarget = _getPrototypeOf(this).constructor;
                    result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                    result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
            };
        }
        function _possibleConstructorReturn(self, call) {
            if (call && (_typeof(call) === "object" || typeof call === "function")) {
                return call;
            } else if (call !== void 0) {
                throw new TypeError("Derived constructors may only return object or undefined");
            }
            return _assertThisInitialized(self);
        }
        function _assertThisInitialized(self) {
            if (self === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
            }
            return self;
        }
        function _isNativeReflectConstruct() {
            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
            if (Reflect.construct.sham) return false;
            if (typeof Proxy === "function") return true;
            try {
                Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
                return true;
            } catch (e) {
                return false;
            }
        }
        function _getPrototypeOf(o) {
            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
            };
            return _getPrototypeOf(o);
        }
        function _defineProperty(obj, key, value) {
            if (key in obj) {
                Object.defineProperty(obj, key, {
                    value,
                    enumerable: true,
                    configurable: true,
                    writable: true
                });
            } else {
                obj[key] = value;
            }
            return obj;
        }
        var FileUploader = function(_Component) {
            _inherits(FileUploader, _Component);
            var _super = _createSuper(FileUploader);
            function FileUploader() {
                var _this;
                _classCallCheck(this, FileUploader);
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                    args[_key] = arguments[_key];
                }
                _this = _super.call.apply(_super, [ this ].concat(args));
                _defineProperty(_assertThisInitialized(_this), "onSelect", (function() {
                    var attachments = _this.frame.state().get("selection").toJSON();
                    _this.props.onChange(attachments.map((function(_ref) {
                        var id = _ref.id, url = _ref.url, title = _ref.title, filename = _ref.filename;
                        return {
                            id,
                            url,
                            title,
                            filename
                        };
                    })));
                    _this.frame.close();
                }));
                return _this;
            }
            _createClass(FileUploader, [ {
                key: "initFrame",
                value: function initFrame() {
                    var _this2 = this;
                    this.frame = wp.media({
                        button: {
                            text: "Select",
                            close: false
                        },
                        states: [ new wp.media.controller.Library({
                            title: "Select File",
                            library: wp.media.query({
                                type: this.props.options.mediaType || "*"
                            }),
                            multiple: this.props.options.multiple,
                            date: false,
                            priority: 20
                        }) ]
                    });
                    this.frame.on("select", this.onSelect, this);
                    this.frame.on("close", (function() {
                        _this2.props.options.onFrameClose && _this2.props.options.onFrameClose();
                    }));
                }
            }, {
                key: "openFrame",
                value: function openFrame() {
                    this.initFrame();
                    this.frame.setState("library").open();
                    this.props.options.onFrameOpen && this.props.options.onFrameOpen();
                }
            }, {
                key: "render",
                value: function render() {
                    var _this3 = this;
                    var value = this.props.value;
                    var emptyLabel = this.props.options.emptyLabel;
                    return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)("div", {
                        className: (0, clsx__WEBPACK_IMPORTED_MODULE_1__["default"])("lotta-file-uploader"),
                        children: [ (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("button", {
                            type: "button",
                            onClick: function onClick() {
                                return _this3.openFrame();
                            },
                            className: "button lotta-upload-button",
                            children: emptyLabel || "Select File"
                        }), Array.isArray(value) && value.length > 0 && (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("ul", {
                            className: "lotta-file-list",
                            children: value.map((function(_ref2, index) {
                                var id = _ref2.id, filename = _ref2.filename;
                                return (0, react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("li", {
                                    children: filename
                                }, id);
                            }))
                        }) ]
                    });
                }
            } ]);
            return FileUploader;
        }(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.Component);
        const __WEBPACK_DEFAULT_EXPORT__ = FileUploader;
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
    }, (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
        "use strict";
        __webpack_require__.r(__webpack_exports__);
    } ];
    var __webpack_module_cache__ = {};
    function __webpack_require__(moduleId) {
        var cachedModule = __webpack_module_cache__[moduleId];
        if (cachedModule !== undefined) {
            return cachedModule.exports;
        }
        var module = __webpack_module_cache__[moduleId] = {
            exports: {}
        };
        __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
        return module.exports;
    }
    __webpack_require__.m = __webpack_modules__;
    (() => {
        var deferred = [];
        __webpack_require__.O = (result, chunkIds, fn, priority) => {
            if (chunkIds) {
                priority = priority || 0;
                for (var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
                deferred[i] = [ chunkIds, fn, priority ];
                return;
            }
            var notFulfilled = Infinity;
            for (var i = 0; i < deferred.length; i++) {
                var [chunkIds, fn, priority] = deferred[i];
                var fulfilled = true;
                for (var j = 0; j < chunkIds.length; j++) {
                    if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key => __webpack_require__.O[key](chunkIds[j])))) {
                        chunkIds.splice(j--, 1);
                    } else {
                        fulfilled = false;
                        if (priority < notFulfilled) notFulfilled = priority;
                    }
                }
                if (fulfilled) {
                    deferred.splice(i--, 1);
                    var r = fn();
                    if (r !== undefined) result = r;
                }
            }
            return result;
        };
    })();
    (() => {
        __webpack_require__.n = module => {
            var getter = module && module.__esModule ? () => module["default"] : () => module;
            __webpack_require__.d(getter, {
                a: getter
            });
            return getter;
        };
    })();
    (() => {
        __webpack_require__.d = (exports, definition) => {
            for (var key in definition) {
                if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
                    Object.defineProperty(exports, key, {
                        enumerable: true,
                        get: definition[key]
                    });
                }
            }
        };
    })();
    (() => {
        __webpack_require__.g = function() {
            if (typeof globalThis === "object") return globalThis;
            try {
                return this || new Function("return this")();
            } catch (e) {
                if (typeof window === "object") return window;
            }
        }();
    })();
    (() => {
        __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
    })();
    (() => {
        __webpack_require__.r = exports => {
            if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
                Object.defineProperty(exports, Symbol.toStringTag, {
                    value: "Module"
                });
            }
            Object.defineProperty(exports, "__esModule", {
                value: true
            });
        };
    })();
    (() => {
        var installedChunks = {
            0: 0,
            2: 0,
            3: 0
        };
        __webpack_require__.O.j = chunkId => installedChunks[chunkId] === 0;
        var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
            var [chunkIds, moreModules, runtime] = data;
            var moduleId, chunkId, i = 0;
            if (chunkIds.some((id => installedChunks[id] !== 0))) {
                for (moduleId in moreModules) {
                    if (__webpack_require__.o(moreModules, moduleId)) {
                        __webpack_require__.m[moduleId] = moreModules[moduleId];
                    }
                }
                if (runtime) var result = runtime(__webpack_require__);
            }
            if (parentChunkLoadingFunction) parentChunkLoadingFunction(data);
            for (;i < chunkIds.length; i++) {
                chunkId = chunkIds[i];
                if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
                    installedChunks[chunkId][0]();
                }
                installedChunks[chunkId] = 0;
            }
            return __webpack_require__.O(result);
        };
        var chunkLoadingGlobal = self["webpackChunklotta_framework"] = self["webpackChunklotta_framework"] || [];
        chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
        chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
    })();
    __webpack_require__.O(undefined, [ 2, 3 ], (() => __webpack_require__(0)));
    __webpack_require__.O(undefined, [ 2, 3 ], (() => __webpack_require__(333)));
    var __webpack_exports__ = __webpack_require__.O(undefined, [ 2, 3 ], (() => __webpack_require__(334)));
    __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
})();