pds-dev-kit-web-test 0.0.21 → 0.0.23

package/dist/storybook-static/1.f296d183a17268696d73.manager.bundle.js

@@ -0,0 +1,190 @@
+(window.webpackJsonp = window.webpackJsonp || []).push([[1], { 939: function (module, __webpack_exports__, __webpack_require__) {
+            "use strict";
+            var objectWithoutPropertiesLoose = __webpack_require__(46), esm_extends = __webpack_require__(12), inheritsLoose = __webpack_require__(133), react = __webpack_require__(0), react_default = __webpack_require__.n(react), react_dom = __webpack_require__(158), ManagerReferenceNodeContext = react.createContext(), ManagerReferenceNodeSetterContext = react.createContext();
+            function Manager(_ref) { var children = _ref.children, _React$useState = react.useState(null), referenceNode = _React$useState[0], setReferenceNode = _React$useState[1]; return react.useEffect((function () { return function () { setReferenceNode(null); }; }), [setReferenceNode]), react.createElement(ManagerReferenceNodeContext.Provider, { value: referenceNode }, react.createElement(ManagerReferenceNodeSetterContext.Provider, { value: setReferenceNode }, children)); }
+            var unwrapArray = function unwrapArray(arg) { return Array.isArray(arg) ? arg[0] : arg; }, safeInvoke = function safeInvoke(fn) { if ("function" == typeof fn) {
+                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);
+            } }, setRef = function setRef(ref, node) { if ("function" == typeof ref)
+                return safeInvoke(ref, node); null != ref && (ref.current = node); }, fromEntries = function fromEntries(entries) { return entries.reduce((function (acc, _ref) { var key = _ref[0], value = _ref[1]; return acc[key] = value, acc; }), {}); }, useIsomorphicLayoutEffect = "undefined" != typeof window && window.document && window.document.createElement ? react.useLayoutEffect : react.useEffect;
+            function getBoundingClientRect(element) { var rect = element.getBoundingClientRect(); return { width: rect.width, height: rect.height, top: rect.top, right: rect.right, bottom: rect.bottom, left: rect.left, x: rect.left, y: rect.top }; }
+            function getWindow(node) { if ("[object Window]" !== node.toString()) {
+                var ownerDocument = node.ownerDocument;
+                return ownerDocument && ownerDocument.defaultView || window;
+            } return node; }
+            function getWindowScroll(node) { var win = getWindow(node); return { scrollLeft: win.pageXOffset, scrollTop: win.pageYOffset }; }
+            function isElement(node) { return node instanceof getWindow(node).Element || node instanceof Element; }
+            function isHTMLElement(node) { return node instanceof getWindow(node).HTMLElement || node instanceof HTMLElement; }
+            function isShadowRoot(node) { return "undefined" != typeof ShadowRoot && (node instanceof getWindow(node).ShadowRoot || node instanceof ShadowRoot); }
+            function getNodeName(element) { return element ? (element.nodeName || "").toLowerCase() : null; }
+            function getDocumentElement(element) { return ((isElement(element) ? element.ownerDocument : element.document) || window.document).documentElement; }
+            function getWindowScrollBarX(element) { return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; }
+            function getComputedStyle(element) { return getWindow(element).getComputedStyle(element); }
+            function isScrollParent(element) { var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY; return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); }
+            function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { void 0 === isFixed && (isFixed = !1); var documentElement = getDocumentElement(offsetParent), rect = getBoundingClientRect(elementOrVirtualElement), isOffsetParentAnElement = isHTMLElement(offsetParent), scroll = { scrollLeft: 0, scrollTop: 0 }, offsets = { x: 0, y: 0 }; return (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) && (("body" !== getNodeName(offsetParent) || isScrollParent(documentElement)) && (scroll = function getNodeScroll(node) { return node !== getWindow(node) && isHTMLElement(node) ? function getHTMLElementScroll(element) { return { scrollLeft: element.scrollLeft, scrollTop: element.scrollTop }; }(node) : getWindowScroll(node); }(offsetParent)), isHTMLElement(offsetParent) ? ((offsets = getBoundingClientRect(offsetParent)).x += offsetParent.clientLeft, offsets.y += offsetParent.clientTop) : documentElement && (offsets.x = getWindowScrollBarX(documentElement))), { x: rect.left + scroll.scrollLeft - offsets.x, y: rect.top + scroll.scrollTop - offsets.y, width: rect.width, height: rect.height }; }
+            function getLayoutRect(element) { return { x: element.offsetLeft, y: element.offsetTop, width: element.offsetWidth, height: element.offsetHeight }; }
+            function getParentNode(element) { return "html" === getNodeName(element) ? element : element.assignedSlot || element.parentNode || (isShadowRoot(element) ? element.host : null) || getDocumentElement(element); }
+            function getScrollParent(node) { return ["html", "body", "#document"].indexOf(getNodeName(node)) >= 0 ? node.ownerDocument.body : isHTMLElement(node) && isScrollParent(node) ? node : getScrollParent(getParentNode(node)); }
+            function listScrollParents(element, list) { var _element$ownerDocumen; void 0 === list && (list = []); var scrollParent = getScrollParent(element), isBody = scrollParent === (null == (_element$ownerDocumen = element.ownerDocument) ? void 0 : _element$ownerDocumen.body), win = getWindow(scrollParent), target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent, updatedList = list.concat(target); return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode(target))); }
+            function isTableElement(element) { return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0; }
+            function getTrueOffsetParent(element) { return isHTMLElement(element) && "fixed" !== getComputedStyle(element).position ? element.offsetParent : null; }
+            function getOffsetParent(element) { for (var window = getWindow(element), offsetParent = getTrueOffsetParent(element); offsetParent && isTableElement(offsetParent) && "static" === getComputedStyle(offsetParent).position;)
+                offsetParent = getTrueOffsetParent(offsetParent); return offsetParent && ("html" === getNodeName(offsetParent) || "body" === getNodeName(offsetParent) && "static" === getComputedStyle(offsetParent).position) ? window : offsetParent || function getContainingBlock(element) { for (var isFirefox = navigator.userAgent.toLowerCase().includes("firefox"), currentNode = getParentNode(element); isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0;) {
+                var css = getComputedStyle(currentNode);
+                if ("none" !== css.transform || "none" !== css.perspective || "paint" === css.contain || ["transform", "perspective"].includes(css.willChange) || isFirefox && "filter" === css.willChange || isFirefox && css.filter && "none" !== css.filter)
+                    return currentNode;
+                currentNode = currentNode.parentNode;
+            } return null; }(element) || window; }
+            var enums_top = "top", bottom = "bottom", right = "right", left = "left", basePlacements = [enums_top, bottom, right, left], variationPlacements = basePlacements.reduce((function (acc, placement) { return acc.concat([placement + "-start", placement + "-end"]); }), []), enums_placements = [].concat(basePlacements, ["auto"]).reduce((function (acc, placement) { return acc.concat([placement, placement + "-start", placement + "-end"]); }), []), modifierPhases = ["beforeRead", "read", "afterRead", "beforeMain", "main", "afterMain", "beforeWrite", "write", "afterWrite"];
+            function order(modifiers) { var map = new Map, visited = new Set, result = []; function sort(modifier) { visited.add(modifier.name), [].concat(modifier.requires || [], modifier.requiresIfExists || []).forEach((function (dep) { if (!visited.has(dep)) {
+                var depModifier = map.get(dep);
+                depModifier && sort(depModifier);
+            } })), result.push(modifier); } return modifiers.forEach((function (modifier) { map.set(modifier.name, modifier); })), modifiers.forEach((function (modifier) { visited.has(modifier.name) || sort(modifier); })), result; }
+            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 && "function" == typeof element.getBoundingClientRect); })); }
+            function popperGenerator(generatorOptions) { void 0 === generatorOptions && (generatorOptions = {}); var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers = void 0 === _generatorOptions$def ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = void 0 === _generatorOptions$def2 ? DEFAULT_OPTIONS : _generatorOptions$def2; return function createPopper(reference, popper, options) { void 0 === options && (options = defaultOptions); var fn, pending, state = { placement: "bottom", orderedModifiers: [], options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), modifiersData: {}, elements: { reference: reference, popper: popper }, attributes: {}, styles: {} }, effectCleanupFns = [], isDestroyed = !1, instance = { state: state, setOptions: function setOptions(options) { cleanupModifierEffects(), state.options = Object.assign({}, defaultOptions, state.options, options), state.scrollParents = { reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], popper: listScrollParents(popper) }; var orderedModifiers = function orderModifiers(modifiers) { var orderedModifiers = order(modifiers); return modifierPhases.reduce((function (acc, phase) { return acc.concat(orderedModifiers.filter((function (modifier) { return modifier.phase === phase; }))); }), []); }(function mergeByName(modifiers) { var merged = modifiers.reduce((function (merged, current) { var existing = merged[current.name]; return merged[current.name] = existing ? Object.assign({}, existing, current, { options: Object.assign({}, existing.options, current.options), data: Object.assign({}, existing.data, current.data) }) : current, merged; }), {}); return Object.keys(merged).map((function (key) { return merged[key]; })); }([].concat(defaultModifiers, state.options.modifiers))); return state.orderedModifiers = orderedModifiers.filter((function (m) { return m.enabled; })), function runModifierEffects() { state.orderedModifiers.forEach((function (_ref3) { var name = _ref3.name, _ref3$options = _ref3.options, options = void 0 === _ref3$options ? {} : _ref3$options, effect = _ref3.effect; if ("function" == typeof effect) {
+                    var cleanupFn = effect({ state: state, name: name, instance: instance, options: options }), noopFn = function noopFn() { };
+                    effectCleanupFns.push(cleanupFn || noopFn);
+                } })); }(), instance.update(); }, forceUpdate: function forceUpdate() { if (!isDestroyed) {
+                    var _state$elements = state.elements, reference = _state$elements.reference, popper = _state$elements.popper;
+                    if (areValidElements(reference, popper)) {
+                        state.rects = { reference: getCompositeRect(reference, getOffsetParent(popper), "fixed" === state.options.strategy), popper: getLayoutRect(popper) }, state.reset = !1, state.placement = state.options.placement, state.orderedModifiers.forEach((function (modifier) { return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); }));
+                        for (var index = 0; index < state.orderedModifiers.length; index++)
+                            if (!0 !== state.reset) {
+                                var _state$orderedModifie = state.orderedModifiers[index], fn = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = void 0 === _state$orderedModifie2 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
+                                "function" == typeof fn && (state = fn({ state: state, options: _options, name: name, instance: instance }) || state);
+                            }
+                            else
+                                state.reset = !1, index = -1;
+                    }
+                } }, update: (fn = function () { return new Promise((function (resolve) { instance.forceUpdate(), resolve(state); })); }, function () { return pending || (pending = new Promise((function (resolve) { Promise.resolve().then((function () { pending = void 0, resolve(fn()); })); }))), pending; }), destroy: function destroy() { cleanupModifierEffects(), isDestroyed = !0; } }; if (!areValidElements(reference, popper))
+                return instance; function cleanupModifierEffects() { effectCleanupFns.forEach((function (fn) { return fn(); })), effectCleanupFns = []; } return instance.setOptions(options).then((function (state) { !isDestroyed && options.onFirstUpdate && options.onFirstUpdate(state); })), instance; }; }
+            var passive = { passive: !0 };
+            var eventListeners = { name: "eventListeners", enabled: !0, phase: "write", fn: function fn() { }, effect: function effect(_ref) { var state = _ref.state, instance = _ref.instance, options = _ref.options, _options$scroll = options.scroll, scroll = void 0 === _options$scroll || _options$scroll, _options$resize = options.resize, resize = void 0 === _options$resize || _options$resize, window = getWindow(state.elements.popper), scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); return scroll && scrollParents.forEach((function (scrollParent) { scrollParent.addEventListener("scroll", instance.update, passive); })), resize && window.addEventListener("resize", instance.update, passive), function () { scroll && scrollParents.forEach((function (scrollParent) { scrollParent.removeEventListener("scroll", instance.update, passive); })), resize && window.removeEventListener("resize", instance.update, passive); }; }, data: {} };
+            function getBasePlacement(placement) { return placement.split("-")[0]; }
+            function getVariation(placement) { return placement.split("-")[1]; }
+            function getMainAxisFromPlacement(placement) { return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y"; }
+            function computeOffsets(_ref) { var offsets, reference = _ref.reference, element = _ref.element, placement = _ref.placement, basePlacement = placement ? getBasePlacement(placement) : null, variation = placement ? getVariation(placement) : null, commonX = reference.x + reference.width / 2 - element.width / 2, commonY = reference.y + reference.height / 2 - element.height / 2; switch (basePlacement) {
+                case enums_top:
+                    offsets = { x: commonX, y: reference.y - element.height };
+                    break;
+                case bottom:
+                    offsets = { x: commonX, y: reference.y + reference.height };
+                    break;
+                case right:
+                    offsets = { x: reference.x + reference.width, y: commonY };
+                    break;
+                case left:
+                    offsets = { x: reference.x - element.width, y: commonY };
+                    break;
+                default: offsets = { x: reference.x, y: reference.y };
+            } var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; if (null != mainAxis) {
+                var len = "y" === mainAxis ? "height" : "width";
+                switch (variation) {
+                    case "start":
+                        offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+                        break;
+                    case "end": offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+                }
+            } return offsets; }
+            var modifiers_popperOffsets = { name: "popperOffsets", enabled: !0, phase: "read", fn: function popperOffsets_popperOffsets(_ref) { var state = _ref.state, name = _ref.name; state.modifiersData[name] = computeOffsets({ reference: state.rects.reference, element: state.rects.popper, strategy: "absolute", placement: state.placement }); }, data: {} }, math_max = Math.max, math_min = Math.min, round = Math.round, unsetSides = { top: "auto", right: "auto", bottom: "auto", left: "auto" };
+            function mapToStyles(_ref2) { var _Object$assign2, popper = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, _ref3 = !0 === roundOffsets ? function roundOffsetsByDPR(_ref) { var x = _ref.x, y = _ref.y, dpr = window.devicePixelRatio || 1; return { x: round(round(x * dpr) / dpr) || 0, y: round(round(y * dpr) / dpr) || 0 }; }(offsets) : "function" == typeof roundOffsets ? roundOffsets(offsets) : offsets, _ref3$x = _ref3.x, x = void 0 === _ref3$x ? 0 : _ref3$x, _ref3$y = _ref3.y, y = void 0 === _ref3$y ? 0 : _ref3$y, hasX = offsets.hasOwnProperty("x"), hasY = offsets.hasOwnProperty("y"), sideX = left, sideY = enums_top, win = window; if (adaptive) {
+                var offsetParent = getOffsetParent(popper), heightProp = "clientHeight", widthProp = "clientWidth";
+                offsetParent === getWindow(popper) && "static" !== getComputedStyle(offsetParent = getDocumentElement(popper)).position && (heightProp = "scrollHeight", widthProp = "scrollWidth"), placement === enums_top && (sideY = bottom, y -= offsetParent[heightProp] - popperRect.height, y *= gpuAcceleration ? 1 : -1), placement === left && (sideX = right, x -= offsetParent[widthProp] - popperRect.width, x *= gpuAcceleration ? 1 : -1);
+            } var _Object$assign, commonStyles = Object.assign({ position: position }, adaptive && unsetSides); return gpuAcceleration ? Object.assign({}, commonStyles, ((_Object$assign = {})[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)) : Object.assign({}, commonStyles, ((_Object$assign2 = {})[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2)); }
+            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]; })); }
+            var getOppositeVariationPlacement_hash = { start: "end", end: "start" };
+            function getOppositeVariationPlacement(placement) { return placement.replace(/start|end/g, (function (matched) { return getOppositeVariationPlacement_hash[matched]; })); }
+            function contains(parent, child) { var rootNode = child.getRootNode && child.getRootNode(); if (parent.contains(child))
+                return !0; if (rootNode && isShadowRoot(rootNode)) {
+                var next = child;
+                do {
+                    if (next && parent.isSameNode(next))
+                        return !0;
+                    next = next.parentNode || next.host;
+                } while (next);
+            } return !1; }
+            function rectToClientRect(rect) { return Object.assign({}, rect, { left: rect.x, top: rect.y, right: rect.x + rect.width, bottom: rect.y + rect.height }); }
+            function getClientRectFromMixedType(element, clippingParent) { return "viewport" === clippingParent ? rectToClientRect(function getViewportRect(element) { var win = getWindow(element), html = getDocumentElement(element), visualViewport = win.visualViewport, width = html.clientWidth, height = html.clientHeight, x = 0, y = 0; return visualViewport && (width = visualViewport.width, height = visualViewport.height, /^((?!chrome|android).)*safari/i.test(navigator.userAgent) || (x = visualViewport.offsetLeft, y = visualViewport.offsetTop)), { width: width, height: height, x: x + getWindowScrollBarX(element), y: y }; }(element)) : isHTMLElement(clippingParent) ? function getInnerBoundingClientRect(element) { var rect = getBoundingClientRect(element); return 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, rect; }(clippingParent) : rectToClientRect(function getDocumentRect(element) { var _element$ownerDocumen, html = getDocumentElement(element), winScroll = getWindowScroll(element), body = null == (_element$ownerDocumen = element.ownerDocument) ? void 0 : _element$ownerDocumen.body, width = math_max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0), height = math_max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0), x = -winScroll.scrollLeft + getWindowScrollBarX(element), y = -winScroll.scrollTop; return "rtl" === getComputedStyle(body || html).direction && (x += math_max(html.clientWidth, body ? body.clientWidth : 0) - width), { width: width, height: height, x: x, y: y }; }(getDocumentElement(element))); }
+            function getClippingRect(element, boundary, rootBoundary) { var mainClippingParents = "clippingParents" === boundary ? function getClippingParents(element) { var clippingParents = listScrollParents(getParentNode(element)), clipperElement = ["absolute", "fixed"].indexOf(getComputedStyle(element).position) >= 0 && isHTMLElement(element) ? getOffsetParent(element) : element; return isElement(clipperElement) ? clippingParents.filter((function (clippingParent) { return isElement(clippingParent) && contains(clippingParent, clipperElement) && "body" !== getNodeName(clippingParent); })) : []; }(element) : [].concat(boundary), clippingParents = [].concat(mainClippingParents, [rootBoundary]), firstClippingParent = clippingParents[0], clippingRect = clippingParents.reduce((function (accRect, clippingParent) { var rect = getClientRectFromMixedType(element, clippingParent); return accRect.top = math_max(rect.top, accRect.top), accRect.right = math_min(rect.right, accRect.right), accRect.bottom = math_min(rect.bottom, accRect.bottom), accRect.left = math_max(rect.left, accRect.left), accRect; }), getClientRectFromMixedType(element, firstClippingParent)); return clippingRect.width = clippingRect.right - clippingRect.left, clippingRect.height = clippingRect.bottom - clippingRect.top, clippingRect.x = clippingRect.left, clippingRect.y = clippingRect.top, clippingRect; }
+            function mergePaddingObject(paddingObject) { return Object.assign({}, { top: 0, right: 0, bottom: 0, left: 0 }, paddingObject); }
+            function expandToHashMap(value, keys) { return keys.reduce((function (hashMap, key) { return hashMap[key] = value, hashMap; }), {}); }
+            function detectOverflow(state, options) { void 0 === options && (options = {}); var _options = options, _options$placement = _options.placement, placement = void 0 === _options$placement ? state.placement : _options$placement, _options$boundary = _options.boundary, boundary = void 0 === _options$boundary ? "clippingParents" : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = void 0 === _options$rootBoundary ? "viewport" : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = void 0 === _options$elementConte ? "popper" : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = void 0 !== _options$altBoundary && _options$altBoundary, _options$padding = _options.padding, padding = void 0 === _options$padding ? 0 : _options$padding, paddingObject = mergePaddingObject("number" != typeof padding ? padding : expandToHashMap(padding, basePlacements)), altContext = "popper" === elementContext ? "reference" : "popper", referenceElement = state.elements.reference, popperRect = state.rects.popper, element = state.elements[altBoundary ? altContext : elementContext], clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary), referenceClientRect = getBoundingClientRect(referenceElement), popperOffsets = computeOffsets({ reference: referenceClientRect, element: popperRect, strategy: "absolute", placement: placement }), popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)), elementClientRect = "popper" === elementContext ? popperClientRect : referenceClientRect, 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 }, offsetData = state.modifiersData.offset; if ("popper" === elementContext && offsetData) {
+                var offset = offsetData[placement];
+                Object.keys(overflowOffsets).forEach((function (key) { var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1, axis = [enums_top, bottom].indexOf(key) >= 0 ? "y" : "x"; overflowOffsets[key] += offset[axis] * multiply; }));
+            } return overflowOffsets; }
+            function within(min, value, max) { return math_max(min, math_min(value, max)); }
+            function getSideOffsets(overflow, rect, preventedOffsets) { return void 0 === preventedOffsets && (preventedOffsets = { x: 0, y: 0 }), { 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_top, right, bottom, left].some((function (side) { return overflow[side] >= 0; })); }
+            var popper_createPopper = popperGenerator({ defaultModifiers: [eventListeners, modifiers_popperOffsets, { name: "computeStyles", enabled: !0, phase: "beforeWrite", fn: function computeStyles(_ref4) { var state = _ref4.state, options = _ref4.options, _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = void 0 === _options$gpuAccelerat || _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = void 0 === _options$adaptive || _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = void 0 === _options$roundOffsets || _options$roundOffsets, commonStyles = { placement: getBasePlacement(state.placement), popper: state.elements.popper, popperRect: state.rects.popper, gpuAcceleration: gpuAcceleration }; null != state.modifiersData.popperOffsets && (state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { offsets: state.modifiersData.popperOffsets, position: state.options.strategy, adaptive: adaptive, roundOffsets: roundOffsets })))), null != state.modifiersData.arrow && (state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { offsets: state.modifiersData.arrow, position: "absolute", adaptive: !1, roundOffsets: roundOffsets })))), state.attributes.popper = Object.assign({}, state.attributes.popper, { "data-popper-placement": state.placement }); }, data: {} }, { name: "applyStyles", enabled: !0, phase: "write", fn: function applyStyles(_ref) { var state = _ref.state; Object.keys(state.elements).forEach((function (name) { var style = state.styles[name] || {}, attributes = state.attributes[name] || {}, element = state.elements[name]; isHTMLElement(element) && getNodeName(element) && (Object.assign(element.style, style), Object.keys(attributes).forEach((function (name) { var value = attributes[name]; !1 === value ? element.removeAttribute(name) : element.setAttribute(name, !0 === value ? "" : value); }))); })); }, effect: function applyStyles_effect(_ref2) { var state = _ref2.state, initialStyles = { popper: { position: state.options.strategy, left: "0", top: "0", margin: "0" }, arrow: { position: "absolute" }, reference: {} }; return Object.assign(state.elements.popper.style, initialStyles.popper), state.styles = initialStyles, state.elements.arrow && Object.assign(state.elements.arrow.style, initialStyles.arrow), function () { Object.keys(state.elements).forEach((function (name) { var element = state.elements[name], attributes = state.attributes[name] || {}, style = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]).reduce((function (style, property) { return style[property] = "", style; }), {}); isHTMLElement(element) && getNodeName(element) && (Object.assign(element.style, style), Object.keys(attributes).forEach((function (attribute) { element.removeAttribute(attribute); }))); })); }; }, requires: ["computeStyles"] }, { name: "offset", enabled: !0, phase: "main", requires: ["popperOffsets"], fn: function offset_offset(_ref2) { var state = _ref2.state, options = _ref2.options, name = _ref2.name, _options$offset = options.offset, offset = void 0 === _options$offset ? [0, 0] : _options$offset, data = enums_placements.reduce((function (acc, placement) { return acc[placement] = function distanceAndSkiddingToXY(placement, rects, offset) { var basePlacement = getBasePlacement(placement), invertDistance = [left, enums_top].indexOf(basePlacement) >= 0 ? -1 : 1, _ref = "function" == typeof offset ? offset(Object.assign({}, rects, { placement: placement })) : offset, skidding = _ref[0], distance = _ref[1]; return skidding = skidding || 0, distance = (distance || 0) * invertDistance, [left, right].indexOf(basePlacement) >= 0 ? { x: distance, y: skidding } : { x: skidding, y: distance }; }(placement, state.rects, offset), acc; }), {}), _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y; null != state.modifiersData.popperOffsets && (state.modifiersData.popperOffsets.x += x, state.modifiersData.popperOffsets.y += y), state.modifiersData[name] = data; } }, { name: "flip", enabled: !0, phase: "main", fn: function flip(_ref) { var state = _ref.state, options = _ref.options, name = _ref.name; if (!state.modifiersData[name]._skip) {
+                            for (var _options$mainAxis = options.mainAxis, checkMainAxis = void 0 === _options$mainAxis || _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = void 0 === _options$altAxis || _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = void 0 === _options$flipVariatio || _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements, preferredPlacement = state.options.placement, basePlacement = getBasePlacement(preferredPlacement), fallbackPlacements = specifiedFallbackPlacements || (basePlacement === preferredPlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : function getExpandedFallbackPlacements(placement) { if ("auto" === getBasePlacement(placement))
+                                return []; var oppositePlacement = getOppositePlacement(placement); return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; }(preferredPlacement)), placements = [preferredPlacement].concat(fallbackPlacements).reduce((function (acc, placement) { return acc.concat("auto" === getBasePlacement(placement) ? function computeAutoPlacement(state, options) { void 0 === options && (options = {}); var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = void 0 === _options$allowedAutoP ? enums_placements : _options$allowedAutoP, variation = getVariation(placement), placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter((function (placement) { return getVariation(placement) === variation; })) : basePlacements, allowedPlacements = placements.filter((function (placement) { return allowedAutoPlacements.indexOf(placement) >= 0; })); 0 === allowedPlacements.length && (allowedPlacements = placements); var overflows = allowedPlacements.reduce((function (acc, placement) { return acc[placement] = detectOverflow(state, { placement: placement, boundary: boundary, rootBoundary: rootBoundary, padding: padding })[getBasePlacement(placement)], acc; }), {}); return Object.keys(overflows).sort((function (a, b) { return overflows[a] - overflows[b]; })); }(state, { placement: placement, boundary: boundary, rootBoundary: rootBoundary, padding: padding, flipVariations: flipVariations, allowedAutoPlacements: allowedAutoPlacements }) : placement); }), []), referenceRect = state.rects.reference, popperRect = state.rects.popper, checksMap = new Map, makeFallbackChecks = !0, firstFittingPlacement = placements[0], i = 0; i < placements.length; i++) {
+                                var placement = placements[i], _basePlacement = getBasePlacement(placement), isStartVariation = "start" === getVariation(placement), isVertical = [enums_top, bottom].indexOf(_basePlacement) >= 0, len = isVertical ? "width" : "height", overflow = detectOverflow(state, { placement: placement, boundary: boundary, rootBoundary: rootBoundary, altBoundary: altBoundary, padding: padding }), mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : enums_top;
+                                referenceRect[len] > popperRect[len] && (mainVariationSide = getOppositePlacement(mainVariationSide));
+                                var altVariationSide = getOppositePlacement(mainVariationSide), checks = [];
+                                if (checkMainAxis && checks.push(overflow[_basePlacement] <= 0), checkAltAxis && checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0), checks.every((function (check) { return check; }))) {
+                                    firstFittingPlacement = placement, makeFallbackChecks = !1;
+                                    break;
+                                }
+                                checksMap.set(placement, checks);
+                            }
+                            if (makeFallbackChecks)
+                                for (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)
+                                    return firstFittingPlacement = fittingPlacement, "break"; }, _i = flipVariations ? 3 : 1; _i > 0; _i--) {
+                                    if ("break" === _loop(_i))
+                                        break;
+                                }
+                            state.placement !== firstFittingPlacement && (state.modifiersData[name]._skip = !0, state.placement = firstFittingPlacement, state.reset = !0);
+                        } }, requiresIfExists: ["offset"], data: { _skip: !1 } }, { name: "preventOverflow", enabled: !0, phase: "main", fn: function preventOverflow(_ref) { var state = _ref.state, options = _ref.options, name = _ref.name, _options$mainAxis = options.mainAxis, checkMainAxis = void 0 === _options$mainAxis || _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = void 0 !== _options$altAxis && _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = void 0 === _options$tether || _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = void 0 === _options$tetherOffset ? 0 : _options$tetherOffset, overflow = detectOverflow(state, { boundary: boundary, rootBoundary: rootBoundary, padding: padding, altBoundary: altBoundary }), basePlacement = getBasePlacement(state.placement), variation = getVariation(state.placement), isBasePlacement = !variation, mainAxis = getMainAxisFromPlacement(basePlacement), altAxis = function getAltAxis(axis) { return "x" === axis ? "y" : "x"; }(mainAxis), popperOffsets = state.modifiersData.popperOffsets, referenceRect = state.rects.reference, popperRect = state.rects.popper, tetherOffsetValue = "function" == typeof tetherOffset ? tetherOffset(Object.assign({}, state.rects, { placement: state.placement })) : tetherOffset, data = { x: 0, y: 0 }; if (popperOffsets) {
+                            if (checkMainAxis || checkAltAxis) {
+                                var mainSide = "y" === mainAxis ? enums_top : left, altSide = "y" === mainAxis ? bottom : right, len = "y" === mainAxis ? "height" : "width", offset = popperOffsets[mainAxis], min = popperOffsets[mainAxis] + overflow[mainSide], max = popperOffsets[mainAxis] - overflow[altSide], additive = tether ? -popperRect[len] / 2 : 0, minLen = "start" === variation ? referenceRect[len] : popperRect[len], maxLen = "start" === variation ? -popperRect[len] : -referenceRect[len], arrowElement = state.elements.arrow, arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { width: 0, height: 0 }, arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : { top: 0, right: 0, bottom: 0, left: 0 }, arrowPaddingMin = arrowPaddingObject[mainSide], arrowPaddingMax = arrowPaddingObject[altSide], arrowLen = within(0, referenceRect[len], arrowRect[len]), minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue, maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue, arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow), clientOffset = arrowOffsetParent ? "y" === mainAxis ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0, offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0, tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset, tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue;
+                                if (checkMainAxis) {
+                                    var preventedOffset = within(tether ? math_min(min, tetherMin) : min, offset, tether ? math_max(max, tetherMax) : max);
+                                    popperOffsets[mainAxis] = preventedOffset, data[mainAxis] = preventedOffset - offset;
+                                }
+                                if (checkAltAxis) {
+                                    var _mainSide = "x" === mainAxis ? enums_top : left, _altSide = "x" === mainAxis ? bottom : right, _offset = popperOffsets[altAxis], _min = _offset + overflow[_mainSide], _max = _offset - overflow[_altSide], _preventedOffset = within(tether ? math_min(_min, tetherMin) : _min, _offset, tether ? math_max(_max, tetherMax) : _max);
+                                    popperOffsets[altAxis] = _preventedOffset, data[altAxis] = _preventedOffset - _offset;
+                                }
+                            }
+                            state.modifiersData[name] = data;
+                        } }, requiresIfExists: ["offset"] }, { name: "arrow", enabled: !0, phase: "main", fn: function arrow(_ref) { var _state$modifiersData$, state = _ref.state, name = _ref.name, arrowElement = state.elements.arrow, popperOffsets = state.modifiersData.popperOffsets, basePlacement = getBasePlacement(state.placement), axis = getMainAxisFromPlacement(basePlacement), len = [left, right].indexOf(basePlacement) >= 0 ? "height" : "width"; if (arrowElement && popperOffsets) {
+                            var paddingObject = state.modifiersData[name + "#persistent"].padding, arrowRect = getLayoutRect(arrowElement), minProp = "y" === axis ? enums_top : left, maxProp = "y" === axis ? bottom : right, endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len], startDiff = popperOffsets[axis] - state.rects.reference[axis], arrowOffsetParent = getOffsetParent(arrowElement), clientSize = arrowOffsetParent ? "y" === axis ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0, centerToReference = endDiff / 2 - startDiff / 2, min = paddingObject[minProp], max = clientSize - arrowRect[len] - paddingObject[maxProp], center = clientSize / 2 - arrowRect[len] / 2 + centerToReference, offset = within(min, center, max), axisProp = axis;
+                            state.modifiersData[name] = ((_state$modifiersData$ = {})[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
+                        } }, effect: function arrow_effect(_ref2) { var state = _ref2.state, options = _ref2.options, name = _ref2.name, _options$element = options.element, arrowElement = void 0 === _options$element ? "[data-popper-arrow]" : _options$element, _options$padding = options.padding, padding = void 0 === _options$padding ? 0 : _options$padding; null != arrowElement && ("string" != typeof arrowElement || (arrowElement = state.elements.popper.querySelector(arrowElement))) && contains(state.elements.popper, arrowElement) && (padding = "function" == typeof padding ? padding(Object.assign({}, state.rects, { placement: state.placement })) : padding, state.elements.arrow = arrowElement, state.modifiersData[name + "#persistent"] = { padding: mergePaddingObject("number" != typeof padding ? padding : expandToHashMap(padding, basePlacements)) }); }, requires: ["popperOffsets"], requiresIfExists: ["preventOverflow"] }, { name: "hide", enabled: !0, phase: "main", requiresIfExists: ["preventOverflow"], fn: function hide(_ref) { var state = _ref.state, name = _ref.name, referenceRect = state.rects.reference, popperRect = state.rects.popper, preventedOffsets = state.modifiersData.preventOverflow, referenceOverflow = detectOverflow(state, { elementContext: "reference" }), popperAltOverflow = detectOverflow(state, { altBoundary: !0 }), referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect), popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets), isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets), hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); state.modifiersData[name] = { referenceClippingOffsets: referenceClippingOffsets, popperEscapeOffsets: popperEscapeOffsets, isReferenceHidden: isReferenceHidden, hasPopperEscaped: hasPopperEscaped }, state.attributes.popper = Object.assign({}, state.attributes.popper, { "data-popper-reference-hidden": isReferenceHidden, "data-popper-escaped": hasPopperEscaped }); } }] }), react_fast_compare = __webpack_require__(396), react_fast_compare_default = __webpack_require__.n(react_fast_compare), EMPTY_MODIFIERS = [], NOOP = function NOOP() { }, NOOP_PROMISE = function NOOP_PROMISE() { return Promise.resolve(null); }, Popper_EMPTY_MODIFIERS = [];
+            function Popper(_ref) { var _ref$placement = _ref.placement, placement = void 0 === _ref$placement ? "bottom" : _ref$placement, _ref$strategy = _ref.strategy, strategy = void 0 === _ref$strategy ? "absolute" : _ref$strategy, _ref$modifiers = _ref.modifiers, modifiers = void 0 === _ref$modifiers ? Popper_EMPTY_MODIFIERS : _ref$modifiers, referenceElement = _ref.referenceElement, onFirstUpdate = _ref.onFirstUpdate, innerRef = _ref.innerRef, children = _ref.children, referenceNode = react.useContext(ManagerReferenceNodeContext), _React$useState = react.useState(null), popperElement = _React$useState[0], setPopperElement = _React$useState[1], _React$useState2 = react.useState(null), arrowElement = _React$useState2[0], setArrowElement = _React$useState2[1]; react.useEffect((function () { setRef(innerRef, popperElement); }), [innerRef, popperElement]); var options = react.useMemo((function () { return { placement: placement, strategy: strategy, onFirstUpdate: onFirstUpdate, modifiers: [].concat(modifiers, [{ name: "arrow", enabled: null != arrowElement, options: { element: arrowElement } }]) }; }), [placement, strategy, onFirstUpdate, modifiers, arrowElement]), _usePopper = function usePopper(referenceElement, popperElement, options) { void 0 === options && (options = {}); var prevOptions = react.useRef(null), optionsWithDefaults = { onFirstUpdate: options.onFirstUpdate, placement: options.placement || "bottom", strategy: options.strategy || "absolute", modifiers: options.modifiers || EMPTY_MODIFIERS }, _React$useState = react.useState({ styles: { popper: { position: optionsWithDefaults.strategy, left: "0", top: "0" } }, attributes: {} }), state = _React$useState[0], setState = _React$useState[1], updateStateModifier = react.useMemo((function () { return { name: "updateState", enabled: !0, phase: "write", fn: function fn(_ref) { var state = _ref.state, elements = Object.keys(state.elements); setState({ styles: fromEntries(elements.map((function (element) { return [element, state.styles[element] || {}]; }))), attributes: fromEntries(elements.map((function (element) { return [element, state.attributes[element]]; }))) }); }, requires: ["computeStyles"] }; }), []), popperOptions = react.useMemo((function () { var newOptions = { onFirstUpdate: optionsWithDefaults.onFirstUpdate, placement: optionsWithDefaults.placement, strategy: optionsWithDefaults.strategy, modifiers: [].concat(optionsWithDefaults.modifiers, [updateStateModifier, { name: "applyStyles", enabled: !1 }]) }; return react_fast_compare_default()(prevOptions.current, newOptions) ? prevOptions.current || newOptions : (prevOptions.current = newOptions, newOptions); }), [optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier]), popperInstanceRef = react.useRef(); return useIsomorphicLayoutEffect((function () { popperInstanceRef.current && popperInstanceRef.current.setOptions(popperOptions); }), [popperOptions]), useIsomorphicLayoutEffect((function () { if (null != referenceElement && null != popperElement) {
+                var popperInstance = (options.createPopper || popper_createPopper)(referenceElement, popperElement, popperOptions);
+                return popperInstanceRef.current = popperInstance, function () { popperInstance.destroy(), popperInstanceRef.current = null; };
+            } }), [referenceElement, popperElement, options.createPopper]), { 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 }; }(referenceElement || referenceNode, popperElement, options), state = _usePopper.state, styles = _usePopper.styles, forceUpdate = _usePopper.forceUpdate, update = _usePopper.update, childrenProps = react.useMemo((function () { return { ref: setPopperElement, style: styles.popper, placement: state ? state.placement : placement, hasPopperEscaped: state && state.modifiersData.hide ? state.modifiersData.hide.hasPopperEscaped : null, isReferenceHidden: state && state.modifiersData.hide ? state.modifiersData.hide.isReferenceHidden : null, arrowProps: { style: styles.arrow, ref: setArrowElement }, forceUpdate: forceUpdate || NOOP, update: update || NOOP_PROMISE }; }), [setPopperElement, setArrowElement, placement, state, styles, update, forceUpdate]); return unwrapArray(children)(childrenProps); }
+            var warning = __webpack_require__(455), warning_default = __webpack_require__.n(warning);
+            function Reference(_ref) { var children = _ref.children, innerRef = _ref.innerRef, setReferenceNode = react.useContext(ManagerReferenceNodeSetterContext), refHandler = react.useCallback((function (node) { setRef(innerRef, node), safeInvoke(setReferenceNode, node); }), [innerRef, setReferenceNode]); return react.useEffect((function () { return function () { return setRef(innerRef, null); }; })), react.useEffect((function () { warning_default()(Boolean(setReferenceNode), "`Reference` should not be used outside of a `Manager` component."); }), [setReferenceNode]), unwrapArray(children)({ ref: refHandler }); }
+            var TooltipContext = react_default.a.createContext({}), callAll = function callAll() { for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++)
+                fns[_key] = arguments[_key]; return function () { for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++)
+                args[_key2] = arguments[_key2]; return fns.forEach((function (fn) { return fn && fn.apply(void 0, args); })); }; }, canUseDOM = function canUseDOM() { return !("undefined" == typeof window || !window.document || !window.document.createElement); }, react_popper_tooltip_setRef = function setRef(ref, node) { if ("function" == typeof ref)
+                return ref(node); null != ref && (ref.current = node); }, react_popper_tooltip_Tooltip = function (_Component) { function Tooltip() { for (var _this, _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)
+                args[_key] = arguments[_key]; return (_this = _Component.call.apply(_Component, [this].concat(args)) || this).observer = void 0, _this.tooltipRef = void 0, _this.handleOutsideClick = function (event) { if (_this.tooltipRef && !_this.tooltipRef.contains(event.target)) {
+                var parentOutsideClickHandler = _this.context.parentOutsideClickHandler, _this$props = _this.props, hideTooltip = _this$props.hideTooltip;
+                (0, _this$props.clearScheduled)(), hideTooltip(), parentOutsideClickHandler && parentOutsideClickHandler(event);
+            } }, _this.handleOutsideRightClick = function (event) { if (_this.tooltipRef && !_this.tooltipRef.contains(event.target)) {
+                var parentOutsideRightClickHandler = _this.context.parentOutsideRightClickHandler, _this$props2 = _this.props, hideTooltip = _this$props2.hideTooltip;
+                (0, _this$props2.clearScheduled)(), hideTooltip(), parentOutsideRightClickHandler && parentOutsideRightClickHandler(event);
+            } }, _this.addOutsideClickHandler = function () { document.body.addEventListener("touchend", _this.handleOutsideClick), document.body.addEventListener("click", _this.handleOutsideClick); }, _this.removeOutsideClickHandler = function () { document.body.removeEventListener("touchend", _this.handleOutsideClick), document.body.removeEventListener("click", _this.handleOutsideClick); }, _this.addOutsideRightClickHandler = function () { return document.body.addEventListener("contextmenu", _this.handleOutsideRightClick); }, _this.removeOutsideRightClickHandler = function () { return document.body.removeEventListener("contextmenu", _this.handleOutsideRightClick); }, _this.getTooltipRef = function (node) { _this.tooltipRef = node, react_popper_tooltip_setRef(_this.props.innerRef, node); }, _this.getArrowProps = function (props) { return void 0 === props && (props = {}), Object(esm_extends.a)({}, props, { style: Object(esm_extends.a)({}, props.style, _this.props.arrowProps.style) }); }, _this.getTooltipProps = function (props) { return void 0 === props && (props = {}), Object(esm_extends.a)({}, props, _this.isTriggeredBy("hover") && { onMouseEnter: callAll(_this.props.clearScheduled, props.onMouseEnter), onMouseLeave: callAll(_this.props.hideTooltip, props.onMouseLeave) }, { style: Object(esm_extends.a)({}, props.style, _this.props.style) }); }, _this.contextValue = { isParentNoneTriggered: "none" === _this.props.trigger, addParentOutsideClickHandler: _this.addOutsideClickHandler, addParentOutsideRightClickHandler: _this.addOutsideRightClickHandler, parentOutsideClickHandler: _this.handleOutsideClick, parentOutsideRightClickHandler: _this.handleOutsideRightClick, removeParentOutsideClickHandler: _this.removeOutsideClickHandler, removeParentOutsideRightClickHandler: _this.removeOutsideRightClickHandler }, _this; } Object(inheritsLoose.a)(Tooltip, _Component); var _proto = Tooltip.prototype; return _proto.componentDidMount = function componentDidMount() { var _this2 = this; if ((this.observer = new MutationObserver((function () { _this2.props.update(); }))).observe(this.tooltipRef, this.props.mutationObserverOptions), this.isTriggeredBy("hover") || this.isTriggeredBy("click") || this.isTriggeredBy("right-click")) {
+                var _this$context = this.context, removeParentOutsideClickHandler = _this$context.removeParentOutsideClickHandler, removeParentOutsideRightClickHandler = _this$context.removeParentOutsideRightClickHandler;
+                this.addOutsideClickHandler(), this.addOutsideRightClickHandler(), removeParentOutsideClickHandler && removeParentOutsideClickHandler(), removeParentOutsideRightClickHandler && removeParentOutsideRightClickHandler();
+            } }, _proto.componentDidUpdate = function componentDidUpdate() { this.props.closeOnReferenceHidden && this.props.isReferenceHidden && this.props.hideTooltip(); }, _proto.componentWillUnmount = function componentWillUnmount() { if (this.observer && this.observer.disconnect(), this.isTriggeredBy("hover") || this.isTriggeredBy("click") || this.isTriggeredBy("right-click")) {
+                var _this$context2 = this.context, isParentNoneTriggered = _this$context2.isParentNoneTriggered, addParentOutsideClickHandler = _this$context2.addParentOutsideClickHandler, addParentOutsideRightClickHandler = _this$context2.addParentOutsideRightClickHandler;
+                this.removeOutsideClickHandler(), this.removeOutsideRightClickHandler(), this.handleOutsideClick = void 0, this.handleOutsideRightClick = void 0, !isParentNoneTriggered && addParentOutsideClickHandler && addParentOutsideClickHandler(), !isParentNoneTriggered && addParentOutsideRightClickHandler && addParentOutsideRightClickHandler();
+            } }, _proto.render = function render() { var _this$props3 = this.props, arrowProps = _this$props3.arrowProps, placement = _this$props3.placement, tooltip = _this$props3.tooltip; return react_default.a.createElement(TooltipContext.Provider, { value: this.contextValue }, tooltip({ arrowRef: arrowProps.ref, getArrowProps: this.getArrowProps, getTooltipProps: this.getTooltipProps, placement: placement, tooltipRef: this.getTooltipRef })); }, _proto.isTriggeredBy = function isTriggeredBy(event) { var trigger = this.props.trigger; return trigger === event || Array.isArray(trigger) && trigger.includes(event); }, Tooltip; }(react.Component);
+            react_popper_tooltip_Tooltip.contextType = TooltipContext;
+            var react_popper_tooltip_TooltipTrigger = function (_Component) { function TooltipTrigger() { for (var _this, _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)
+                args[_key] = arguments[_key]; return (_this = _Component.call.apply(_Component, [this].concat(args)) || this).state = { tooltipShown: _this.props.defaultTooltipShown }, _this.hideTimeout = void 0, _this.showTimeout = void 0, _this.popperOffset = void 0, _this.setTooltipState = function (state) { var cb = function cb() { return _this.props.onVisibilityChange(state.tooltipShown); }; _this.isControlled() ? cb() : _this.setState(state, cb); }, _this.clearScheduled = function () { clearTimeout(_this.hideTimeout), clearTimeout(_this.showTimeout); }, _this.showTooltip = function (_ref) { var pageX = _ref.pageX, pageY = _ref.pageY; _this.clearScheduled(); var state = { tooltipShown: !0 }; _this.props.followCursor && (state = Object(esm_extends.a)({}, state, { pageX: pageX, pageY: pageY })), _this.showTimeout = window.setTimeout((function () { return _this.setTooltipState(state); }), _this.props.delayShow); }, _this.hideTooltip = function () { _this.clearScheduled(), _this.hideTimeout = window.setTimeout((function () { return _this.setTooltipState({ tooltipShown: !1 }); }), _this.props.delayHide); }, _this.toggleTooltip = function (_ref2) { var pageX = _ref2.pageX, pageY = _ref2.pageY, action = _this.getState() ? "hideTooltip" : "showTooltip"; _this[action]({ pageX: pageX, pageY: pageY }); }, _this.clickToggle = function (event) { event.preventDefault(); var pageX = event.pageX, pageY = event.pageY, action = _this.props.followCursor ? "showTooltip" : "toggleTooltip"; _this[action]({ pageX: pageX, pageY: pageY }); }, _this.contextMenuToggle = function (event) { event.preventDefault(); var pageX = event.pageX, pageY = event.pageY, action = _this.props.followCursor ? "showTooltip" : "toggleTooltip"; _this[action]({ pageX: pageX, pageY: pageY }); }, _this.getTriggerProps = function (props) { return void 0 === props && (props = {}), Object(esm_extends.a)({}, props, _this.isTriggeredBy("click") && { onClick: callAll(_this.clickToggle, props.onClick), onTouchEnd: callAll(_this.clickToggle, props.onTouchEnd) }, _this.isTriggeredBy("right-click") && { onContextMenu: callAll(_this.contextMenuToggle, props.onContextMenu) }, _this.isTriggeredBy("hover") && Object(esm_extends.a)({ onMouseEnter: callAll(_this.showTooltip, props.onMouseEnter), onMouseLeave: callAll(_this.hideTooltip, props.onMouseLeave) }, _this.props.followCursor && { onMouseMove: callAll(_this.showTooltip, props.onMouseMove) }), _this.isTriggeredBy("focus") && { onFocus: callAll(_this.showTooltip, props.onFocus), onBlur: callAll(_this.hideTooltip, props.onBlur) }); }, _this; } Object(inheritsLoose.a)(TooltipTrigger, _Component); var _proto = TooltipTrigger.prototype; return _proto.componentWillUnmount = function componentWillUnmount() { this.clearScheduled(); }, _proto.render = function render() { var _this2 = this, _this$props = this.props, children = _this$props.children, tooltip = _this$props.tooltip, placement = _this$props.placement, trigger = _this$props.trigger, getTriggerRef = _this$props.getTriggerRef, modifiers = _this$props.modifiers, closeOnReferenceHidden = _this$props.closeOnReferenceHidden, usePortal = _this$props.usePortal, portalContainer = _this$props.portalContainer, followCursor = _this$props.followCursor, getTooltipRef = _this$props.getTooltipRef, mutationObserverOptions = _this$props.mutationObserverOptions, restProps = Object(objectWithoutPropertiesLoose.a)(_this$props, ["children", "tooltip", "placement", "trigger", "getTriggerRef", "modifiers", "closeOnReferenceHidden", "usePortal", "portalContainer", "followCursor", "getTooltipRef", "mutationObserverOptions"]), popper = react_default.a.createElement(Popper, Object(esm_extends.a)({ innerRef: getTooltipRef, placement: placement, modifiers: [{ name: "followCursor", enabled: followCursor, phase: "main", fn: function fn(data) { _this2.popperOffset = data.state.rects.popper; } }].concat(modifiers) }, restProps), (function (_ref3) { var ref = _ref3.ref, style = _ref3.style, placement = _ref3.placement, arrowProps = _ref3.arrowProps, isReferenceHidden = _ref3.isReferenceHidden, update = _ref3.update; if (followCursor && _this2.popperOffset) {
+                var _this2$state = _this2.state, pageX = _this2$state.pageX, pageY = _this2$state.pageY, _this2$popperOffset = _this2.popperOffset, width = _this2$popperOffset.width, height = _this2$popperOffset.height, x = pageX + width > window.pageXOffset + document.body.offsetWidth ? pageX - width : pageX, y = pageY + height > window.pageYOffset + document.body.offsetHeight ? pageY - height : pageY;
+                style.transform = "translate3d(" + x + "px, " + y + "px, 0";
+            } return react_default.a.createElement(react_popper_tooltip_Tooltip, Object(esm_extends.a)({ arrowProps: arrowProps, closeOnReferenceHidden: closeOnReferenceHidden, isReferenceHidden: isReferenceHidden, placement: placement, update: update, style: style, tooltip: tooltip, trigger: trigger, mutationObserverOptions: mutationObserverOptions }, { clearScheduled: _this2.clearScheduled, hideTooltip: _this2.hideTooltip, innerRef: ref })); })); return react_default.a.createElement(Manager, null, react_default.a.createElement(Reference, { innerRef: getTriggerRef }, (function (_ref4) { var ref = _ref4.ref; return children({ getTriggerProps: _this2.getTriggerProps, triggerRef: ref }); })), this.getState() && (usePortal ? Object(react_dom.createPortal)(popper, portalContainer) : popper)); }, _proto.isControlled = function isControlled() { return void 0 !== this.props.tooltipShown; }, _proto.getState = function getState() { return this.isControlled() ? this.props.tooltipShown : this.state.tooltipShown; }, _proto.isTriggeredBy = function isTriggeredBy(event) { var trigger = this.props.trigger; return trigger === event || Array.isArray(trigger) && trigger.includes(event); }, TooltipTrigger; }(react.Component);
+            react_popper_tooltip_TooltipTrigger.defaultProps = { closeOnReferenceHidden: !0, defaultTooltipShown: !1, delayHide: 0, delayShow: 0, followCursor: !1, onVisibilityChange: function noop() { }, placement: "right", portalContainer: canUseDOM() ? document.body : null, trigger: "hover", usePortal: canUseDOM(), mutationObserverOptions: { childList: !0, subtree: !0 }, modifiers: [] };
+            __webpack_exports__.a = react_popper_tooltip_TooltipTrigger;
+        } }]);

package/dist/storybook-static/10.9998ba67d65d81d20896.manager.bundle.js

@@ -0,0 +1,62 @@
+(window.webpackJsonp = window.webpackJsonp || []).push([[10], { 865: function (module, __webpack_exports__, __webpack_require__) {
+            "use strict";
+            __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, "SyntaxHighlighter", (function () { return syntaxhighlighter_SyntaxHighlighter; }));
+            __webpack_require__(87), __webpack_require__(42), __webpack_require__(43), __webpack_require__(15), __webpack_require__(110), __webpack_require__(4), __webpack_require__(9), __webpack_require__(5), __webpack_require__(13), __webpack_require__(6), __webpack_require__(7), __webpack_require__(10), __webpack_require__(16), __webpack_require__(14), __webpack_require__(17), __webpack_require__(41), __webpack_require__(23);
+            var react = __webpack_require__(0), react_default = __webpack_require__.n(react), esm = __webpack_require__(25), dist_esm = __webpack_require__(1), global_window = __webpack_require__(8), window_default = __webpack_require__.n(global_window), memoizerific = __webpack_require__(28), memoizerific_default = __webpack_require__.n(memoizerific), jsx = __webpack_require__(919), bash = __webpack_require__(926), css = __webpack_require__(928), js_extras = __webpack_require__(917), json = __webpack_require__(920), graphql = __webpack_require__(933), markup = __webpack_require__(929), markdown = __webpack_require__(924), yaml = __webpack_require__(922), tsx = __webpack_require__(930), typescript = __webpack_require__(932), prism_light = __webpack_require__(940), ActionBar = __webpack_require__(862), ScrollArea = __webpack_require__(406), dist = __webpack_require__(33), dist_default = __webpack_require__.n(dist), formatter = memoizerific_default()(2)((function (code) { return dist_default()(code); }));
+            function _extends() { return (_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) {
+                var source = arguments[i];
+                for (var key in source)
+                    Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+            } return target; }).apply(this, arguments); }
+            function _objectWithoutProperties(source, excluded) { if (null == source)
+                return {}; var key, i, target = function _objectWithoutPropertiesLoose(source, excluded) { if (null == source)
+                return {}; var key, i, target = {}, sourceKeys = Object.keys(source); for (i = 0; i < sourceKeys.length; i++)
+                key = sourceKeys[i], excluded.indexOf(key) >= 0 || (target[key] = source[key]); return target; }(source, excluded); if (Object.getOwnPropertySymbols) {
+                var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+                for (i = 0; i < sourceSymbolKeys.length; i++)
+                    key = sourceSymbolKeys[i], excluded.indexOf(key) >= 0 || Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+            } return target; }
+            function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try {
+                var info = gen[key](arg), value = info.value;
+            }
+            catch (error) {
+                return void reject(error);
+            } info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw); }
+            function _slicedToArray(arr, i) { return function _arrayWithHoles(arr) { if (Array.isArray(arr))
+                return arr; }(arr) || function _iterableToArrayLimit(arr, i) { if ("undefined" == typeof Symbol || !(Symbol.iterator in Object(arr)))
+                return; var _arr = [], _n = !0, _d = !1, _e = void 0; try {
+                for (var _s, _i = arr[Symbol.iterator](); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !i || _arr.length !== i); _n = !0)
+                    ;
+            }
+            catch (err) {
+                _d = !0, _e = err;
+            }
+            finally {
+                try {
+                    _n || null == _i.return || _i.return();
+                }
+                finally {
+                    if (_d)
+                        throw _e;
+                }
+            } return _arr; }(arr, i) || function _unsupportedIterableToArray(o, minLen) { if (!o)
+                return; if ("string" == typeof o)
+                return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); "Object" === n && o.constructor && (n = o.constructor.name); if ("Map" === n || "Set" === n)
+                return Array.from(o); if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+                return _arrayLikeToArray(o, minLen); }(arr, i) || 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 _arrayLikeToArray(arr, len) { (null == len || len > arr.length) && (len = arr.length); for (var i = 0, arr2 = new Array(len); i < len; i++)
+                arr2[i] = arr[i]; return arr2; }
+            var syntaxhighlighter_navigator = window_default.a.navigator, syntaxhighlighter_document = window_default.a.document, globalWindow = window_default.a.window;
+            prism_light.a.registerLanguage("jsextra", js_extras.a), prism_light.a.registerLanguage("jsx", jsx.a), prism_light.a.registerLanguage("json", json.a), prism_light.a.registerLanguage("yml", yaml.a), prism_light.a.registerLanguage("md", markdown.a), prism_light.a.registerLanguage("bash", bash.a), prism_light.a.registerLanguage("css", css.a), prism_light.a.registerLanguage("html", markup.a), prism_light.a.registerLanguage("tsx", tsx.a), prism_light.a.registerLanguage("typescript", typescript.a), prism_light.a.registerLanguage("graphql", graphql.a);
+            var copyToClipboard, themedSyntax = memoizerific_default()(2)((function (theme) { return Object.entries(theme.code || {}).reduce((function (acc, _ref) { var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], val = _ref2[1]; return Object.assign({}, acc, function _defineProperty(obj, key, value) { return key in obj ? Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }) : obj[key] = value, obj; }({}, "* .".concat(key), val)); }), {}); }));
+            copyToClipboard = null != syntaxhighlighter_navigator && syntaxhighlighter_navigator.clipboard ? function copyToClipboard(text) { return syntaxhighlighter_navigator.clipboard.writeText(text); } : function () { var _ref3 = function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise((function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(void 0); })); }; }(regeneratorRuntime.mark((function _callee(text) { var tmp, focus; return regeneratorRuntime.wrap((function _callee$(_context) { for (;;)
+                switch (_context.prev = _context.next) {
+                    case 0: tmp = syntaxhighlighter_document.createElement("TEXTAREA"), focus = syntaxhighlighter_document.activeElement, tmp.value = text, syntaxhighlighter_document.body.appendChild(tmp), tmp.select(), syntaxhighlighter_document.execCommand("copy"), syntaxhighlighter_document.body.removeChild(tmp), focus.focus();
+                    case 8:
+                    case "end": return _context.stop();
+                } }), _callee); }))); return function copyToClipboard(_x) { return _ref3.apply(this, arguments); }; }();
+            var Wrapper = dist_esm.styled.div((function (_ref4) { return { position: "relative", overflow: "hidden", color: _ref4.theme.color.defaultText }; }), (function (_ref5) { var theme = _ref5.theme; return _ref5.bordered ? { border: "1px solid ".concat(theme.appBorderColor), borderRadius: theme.borderRadius, background: theme.background.content } : {}; })), Scroller = Object(dist_esm.styled)((function (_ref6) { var children = _ref6.children, className = _ref6.className; return react_default.a.createElement(ScrollArea.a, { horizontal: !0, vertical: !0, className: className }, children); }))({ position: "relative" }, (function (_ref7) { return { "& code": { paddingRight: _ref7.theme.layoutMargin } }; }), (function (_ref8) { var theme = _ref8.theme; return themedSyntax(theme); })), Pre = dist_esm.styled.pre((function (_ref9) { var theme = _ref9.theme; return { display: "flex", justifyContent: "flex-start", margin: 0, padding: _ref9.padded ? theme.layoutMargin : 0 }; })), Code = dist_esm.styled.code({ flex: 1, paddingRight: 0, opacity: 1 }), syntaxhighlighter_SyntaxHighlighter = function SyntaxHighlighter(_ref10) { var children = _ref10.children, _ref10$language = _ref10.language, language = void 0 === _ref10$language ? "jsx" : _ref10$language, _ref10$copyable = _ref10.copyable, copyable = void 0 !== _ref10$copyable && _ref10$copyable, _ref10$bordered = _ref10.bordered, bordered = void 0 !== _ref10$bordered && _ref10$bordered, _ref10$padded = _ref10.padded, padded = void 0 !== _ref10$padded && _ref10$padded, _ref10$format = _ref10.format, format = void 0 === _ref10$format || _ref10$format, _ref10$className = _ref10.className, className = void 0 === _ref10$className ? null : _ref10$className, _ref10$showLineNumber = _ref10.showLineNumbers, showLineNumbers = void 0 !== _ref10$showLineNumber && _ref10$showLineNumber, rest = _objectWithoutProperties(_ref10, ["children", "language", "copyable", "bordered", "padded", "format", "className", "showLineNumbers"]); if ("string" != typeof children || !children.trim())
+                return null; var highlightableCode = format ? formatter(children) : children.trim(), _useState2 = _slicedToArray(Object(react.useState)(!1), 2), copied = _useState2[0], setCopied = _useState2[1]; return react_default.a.createElement(Wrapper, { bordered: bordered, padded: padded, className: className }, react_default.a.createElement(Scroller, null, react_default.a.createElement(prism_light.a, _extends({ padded: padded || bordered, language: language, showLineNumbers: showLineNumbers, showInlineLineNumbers: showLineNumbers, useInlineStyles: !1, PreTag: Pre, CodeTag: Code, lineNumberContainerStyle: {} }, rest), highlightableCode)), copyable ? react_default.a.createElement(ActionBar.a, { actionItems: [{ title: copied ? "Copied" : "Copy", onClick: function onClick(e) { e.preventDefault(), copyToClipboard(highlightableCode).then((function () { setCopied(!0), globalWindow.setTimeout((function () { return setCopied(!1); }), 1500); })).catch(esm.a.error); } }] }) : null); };
+            syntaxhighlighter_SyntaxHighlighter.displayName = "SyntaxHighlighter";
+            __webpack_exports__.default = syntaxhighlighter_SyntaxHighlighter;
+        } }]);

package/dist/storybook-static/11.49c687eaa6261f8b7be2.manager.bundle.d.ts

@@ -0,0 +1,2 @@
+export = __WEBPACK_AMD_DEFINE_RESULT__;
+declare var __WEBPACK_AMD_DEFINE_RESULT__: any;