{"version":3,"file":"static/js/2358_12896603149d596ae953.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/DraggableZone/DraggableZone.styles.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/DraggableZone/DraggableZone.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/MenuContext/MenuContext.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/ThemeContext.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/styleRenderers/mergeStylesRenderer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/useThemeProviderClasses.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/makeStyles.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/renderThemeProvider.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/useThemeProviderState.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/ThemeProvider.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/useThemeProvider.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/ThemeProvider/useTheme.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/contextualMenu/contextualMenuUtility.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/decorators/withResponsiveMode.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/hooks/useResponsiveMode.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/keytips/KeytipConstants.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/keytips/KeytipManager.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/keytips/KeytipUtils.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/positioning/positioning.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/positioning/positioning.types.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/selectableOption/SelectableOption.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.111.4_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/selectableOption/SelectableOption.types.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+set-version@8.2.14/node_modules/@fluentui/set-version/lib/setVersion.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+set-version@8.2.14/node_modules/@fluentui/set-version/lib/index.js"],"sourcesContent":["import { memoizeFunction } from '../../Utilities';\nimport { mergeStyles } from '../../Styling';\nexport var getClassNames = memoizeFunction(function (className, isDragging) {\n    return {\n        root: mergeStyles(className, isDragging && {\n            touchAction: 'none',\n            selectors: {\n                '& *': {\n                    userSelect: 'none',\n                },\n            },\n        }),\n    };\n});\n//# sourceMappingURL=DraggableZone.styles.js.map","import { __assign, __extends } from \"tslib\";\nimport * as React from 'react';\nimport { getClassNames } from './DraggableZone.styles';\nimport { on } from '../../Utilities';\nvar eventMapping = {\n    touch: {\n        start: 'touchstart',\n        move: 'touchmove',\n        stop: 'touchend',\n    },\n    mouse: {\n        start: 'mousedown',\n        move: 'mousemove',\n        stop: 'mouseup',\n    },\n};\nvar DraggableZone = /** @class */ (function (_super) {\n    __extends(DraggableZone, _super);\n    function DraggableZone(props) {\n        var _this = _super.call(this, props) || this;\n        _this._currentEventType = eventMapping.mouse;\n        _this._events = [];\n        _this._onMouseDown = function (event) {\n            var onMouseDown = React.Children.only(_this.props.children).props.onMouseDown;\n            if (onMouseDown) {\n                onMouseDown(event);\n            }\n            _this._currentEventType = eventMapping.mouse;\n            return _this._onDragStart(event);\n        };\n        _this._onMouseUp = function (event) {\n            var onMouseUp = React.Children.only(_this.props.children).props.onMouseUp;\n            if (onMouseUp) {\n                onMouseUp(event);\n            }\n            _this._currentEventType = eventMapping.mouse;\n            return _this._onDragStop(event);\n        };\n        _this._onTouchStart = function (event) {\n            var onTouchStart = React.Children.only(_this.props.children).props.onTouchStart;\n            if (onTouchStart) {\n                onTouchStart(event);\n            }\n            _this._currentEventType = eventMapping.touch;\n            return _this._onDragStart(event);\n        };\n        _this._onTouchEnd = function (event) {\n            var onTouchEnd = React.Children.only(_this.props.children).props.onTouchEnd;\n            if (onTouchEnd) {\n                onTouchEnd(event);\n            }\n            _this._currentEventType = eventMapping.touch;\n            _this._onDragStop(event);\n        };\n        _this._onDragStart = function (event) {\n            // Only handle left click for dragging\n            if (typeof event.button === 'number' && event.button !== 0) {\n                return false;\n            }\n            // If the target doesn't match the handleSelector OR\n            // if the target does match the preventDragSelector, bail out\n            if ((_this.props.handleSelector && !_this._matchesSelector(event.target, _this.props.handleSelector)) ||\n                (_this.props.preventDragSelector &&\n                    _this._matchesSelector(event.target, _this.props.preventDragSelector))) {\n                return;\n            }\n            // Remember the touch identifier if this is a touch event so we can\n            // distinguish between individual touches in multitouch scenarios\n            // by remembering which touch point we were given\n            _this._touchId = _this._getTouchId(event);\n            var position = _this._getControlPosition(event);\n            if (position === undefined) {\n                return;\n            }\n            var dragData = _this._createDragDataFromPosition(position);\n            _this.props.onStart && _this.props.onStart(event, dragData);\n            _this.setState({\n                isDragging: true,\n                lastPosition: position,\n            });\n            // hook up the appropriate mouse/touch events to the body to ensure\n            // smooth dragging\n            _this._events = [\n                on(document.body, _this._currentEventType.move, _this._onDrag, true /* use capture phase */),\n                on(document.body, _this._currentEventType.stop, _this._onDragStop, true /* use capture phase */),\n            ];\n        };\n        _this._onDrag = function (event) {\n            // Prevent scrolling on mobile devices\n            if (event.type === 'touchmove') {\n                event.preventDefault();\n            }\n            var position = _this._getControlPosition(event);\n            if (!position) {\n                return;\n            }\n            // create the updated drag data from the position data\n            var updatedData = _this._createUpdatedDragData(_this._createDragDataFromPosition(position));\n            var updatedPosition = updatedData.position;\n            _this.props.onDragChange && _this.props.onDragChange(event, updatedData);\n            _this.setState({\n                position: updatedPosition,\n                lastPosition: position,\n            });\n        };\n        _this._onDragStop = function (event) {\n            if (!_this.state.isDragging) {\n                return;\n            }\n            var position = _this._getControlPosition(event);\n            if (!position) {\n                return;\n            }\n            var baseDragData = _this._createDragDataFromPosition(position);\n            // Set dragging to false and reset the lastPosition\n            _this.setState({\n                isDragging: false,\n                lastPosition: undefined,\n            });\n            _this.props.onStop && _this.props.onStop(event, baseDragData);\n            if (_this.props.position) {\n                _this.setState({\n                    position: _this.props.position,\n                });\n            }\n            // Remove event handlers\n            _this._events.forEach(function (dispose) { return dispose(); });\n        };\n        _this.state = {\n            isDragging: false,\n            position: _this.props.position || { x: 0, y: 0 },\n            lastPosition: undefined,\n        };\n        return _this;\n    }\n    DraggableZone.prototype.componentDidUpdate = function (prevProps) {\n        if (this.props.position && (!prevProps.position || this.props.position !== prevProps.position)) {\n            this.setState({ position: this.props.position });\n        }\n    };\n    DraggableZone.prototype.componentWillUnmount = function () {\n        this._events.forEach(function (dispose) { return dispose(); });\n    };\n    DraggableZone.prototype.render = function () {\n        var child = React.Children.only(this.props.children);\n        var props = child.props;\n        var position = this.props.position;\n        var _a = this.state, statePosition = _a.position, isDragging = _a.isDragging;\n        var x = statePosition.x;\n        var y = statePosition.y;\n        if (position && !isDragging) {\n            x = position.x;\n            y = position.y;\n        }\n        return React.cloneElement(child, {\n            style: __assign(__assign({}, props.style), { transform: \"translate(\".concat(x, \"px, \").concat(y, \"px)\") }),\n            className: getClassNames(props.className, this.state.isDragging).root,\n            onMouseDown: this._onMouseDown,\n            onMouseUp: this._onMouseUp,\n            onTouchStart: this._onTouchStart,\n            onTouchEnd: this._onTouchEnd,\n        });\n    };\n    /**\n     * Get the control position based off the event that fired\n     * @param event - The event to get offsets from\n     */\n    DraggableZone.prototype._getControlPosition = function (event) {\n        var touchObj = this._getActiveTouch(event);\n        // did we get the right touch?\n        if (this._touchId !== undefined && !touchObj) {\n            return undefined;\n        }\n        var eventToGetOffset = touchObj || event;\n        return {\n            x: eventToGetOffset.clientX,\n            y: eventToGetOffset.clientY,\n        };\n    };\n    /**\n     * Get the active touch point that we have saved from the event's TouchList\n     * @param event - The event used to get the TouchList for the active touch point\n     */\n    DraggableZone.prototype._getActiveTouch = function (event) {\n        return ((event.targetTouches && this._findTouchInTouchList(event.targetTouches)) ||\n            (event.changedTouches && this._findTouchInTouchList(event.changedTouches)));\n    };\n    /**\n     * Get the initial touch identifier associated with the given event\n     * @param event - The event that contains the TouchList\n     */\n    DraggableZone.prototype._getTouchId = function (event) {\n        var touch = (event.targetTouches && event.targetTouches[0]) || (event.changedTouches && event.changedTouches[0]);\n        if (touch) {\n            return touch.identifier;\n        }\n    };\n    /**\n     * Returns if an element (or any of the element's parents) match the given selector\n     */\n    DraggableZone.prototype._matchesSelector = function (element, selector) {\n        if (!element || element === document.body) {\n            return false;\n        }\n        var matchesSelectorFn = \n        // eslint-disable-next-line deprecation/deprecation\n        element.matches || element.webkitMatchesSelector || element.msMatchesSelector; /* for IE */\n        if (!matchesSelectorFn) {\n            return false;\n        }\n        return matchesSelectorFn.call(element, selector) || this._matchesSelector(element.parentElement, selector);\n    };\n    /**\n     * Attempts to find the Touch that matches the identifier  we stored in dragStart\n     * @param touchList The TouchList to look for the stored identifier from dragStart\n     */\n    DraggableZone.prototype._findTouchInTouchList = function (touchList) {\n        if (this._touchId === undefined) {\n            return;\n        }\n        for (var i = 0; i < touchList.length; i++) {\n            if (touchList[i].identifier === this._touchId) {\n                return touchList[i];\n            }\n        }\n        return undefined;\n    };\n    /**\n     * Create DragData based off of the last known position and the new position passed in\n     * @param position The new position as part of the drag\n     */\n    DraggableZone.prototype._createDragDataFromPosition = function (position) {\n        var lastPosition = this.state.lastPosition;\n        // If we have no lastPosition, use the given position\n        // for last position\n        if (lastPosition === undefined) {\n            return {\n                delta: { x: 0, y: 0 },\n                lastPosition: position,\n                position: position,\n            };\n        }\n        return {\n            delta: {\n                x: position.x - lastPosition.x,\n                y: position.y - lastPosition.y,\n            },\n            lastPosition: lastPosition,\n            position: position,\n        };\n    };\n    /**\n     * Creates an updated DragData based off the current position and given baseDragData\n     * @param baseDragData The base DragData (from _createDragDataFromPosition) used to calculate the updated positions\n     */\n    DraggableZone.prototype._createUpdatedDragData = function (baseDragData) {\n        var position = this.state.position;\n        return {\n            position: {\n                x: position.x + baseDragData.delta.x,\n                y: position.y + baseDragData.delta.y,\n            },\n            delta: baseDragData.delta,\n            lastPosition: position,\n        };\n    };\n    return DraggableZone;\n}(React.Component));\nexport { DraggableZone };\n//# sourceMappingURL=DraggableZone.js.map","import * as React from 'react';\nexport var MenuContext = React.createContext({});\nexport var useMenuContext = function () {\n    return React.useContext(MenuContext);\n};\n//# sourceMappingURL=MenuContext.js.map","import * as React from 'react';\nexport var ThemeContext = React.createContext(undefined);\n//# sourceMappingURL=ThemeContext.js.map","import { Stylesheet, mergeCssSets, fontFace as mergeFontFace, keyframes as mergeKeyframes, } from '@fluentui/merge-styles';\nvar _seed = 0;\nexport var mergeStylesRenderer = {\n    reset: function () {\n        // If the stylesheet reset call is made, invalidate the cache keys.\n        Stylesheet.getInstance().onReset(function () { return _seed++; });\n    },\n    getId: function () { return _seed; },\n    renderStyles: function (styleSet, options) {\n        return mergeCssSets((Array.isArray(styleSet) ? styleSet : [styleSet]), options);\n    },\n    renderFontFace: function (fontFace, options) {\n        return mergeFontFace(fontFace);\n    },\n    renderKeyframes: function (keyframes) {\n        return mergeKeyframes(keyframes);\n    },\n};\n//# sourceMappingURL=mergeStylesRenderer.js.map","import * as React from 'react';\nimport { css } from '@fluentui/utilities';\nimport { useDocument } from '@fluentui/react-window-provider';\nimport { makeStyles } from './makeStyles';\n// eslint-disable-next-line deprecation/deprecation\nvar useThemeProviderStyles = makeStyles(function (theme) {\n    var semanticColors = theme.semanticColors, fonts = theme.fonts;\n    return {\n        body: [\n            {\n                color: semanticColors.bodyText,\n                background: semanticColors.bodyBackground,\n                fontFamily: fonts.medium.fontFamily,\n                fontWeight: fonts.medium.fontWeight,\n                fontSize: fonts.medium.fontSize,\n                MozOsxFontSmoothing: fonts.medium.MozOsxFontSmoothing,\n                WebkitFontSmoothing: fonts.medium.WebkitFontSmoothing,\n            },\n        ],\n    };\n});\n/**\n * Hook to add class to body element.\n */\nfunction useApplyClassToBody(state, classesToApply) {\n    var _a;\n    var applyTo = state.applyTo;\n    var applyToBody = applyTo === 'body';\n    var body = (_a = useDocument()) === null || _a === void 0 ? void 0 : _a.body;\n    React.useEffect(function () {\n        if (!applyToBody || !body) {\n            return;\n        }\n        for (var _i = 0, classesToApply_1 = classesToApply; _i < classesToApply_1.length; _i++) {\n            var classToApply = classesToApply_1[_i];\n            if (classToApply) {\n                body.classList.add(classToApply);\n            }\n        }\n        return function () {\n            if (!applyToBody || !body) {\n                return;\n            }\n            for (var _i = 0, classesToApply_2 = classesToApply; _i < classesToApply_2.length; _i++) {\n                var classToApply = classesToApply_2[_i];\n                if (classToApply) {\n                    body.classList.remove(classToApply);\n                }\n            }\n        };\n    }, [applyToBody, body, classesToApply]);\n}\nexport function useThemeProviderClasses(state) {\n    var classes = useThemeProviderStyles(state);\n    var className = state.className, applyTo = state.applyTo;\n    useApplyClassToBody(state, [classes.root, classes.body]);\n    state.className = css(className, classes.root, applyTo === 'element' && classes.body);\n}\n//# sourceMappingURL=useThemeProviderClasses.js.map","import { useTheme } from './useTheme';\nimport { getId } from '@fluentui/utilities';\nimport { useWindow } from '@fluentui/react-window-provider';\nimport { mergeStylesRenderer } from './styleRenderers/mergeStylesRenderer';\nimport { useEffect } from 'react';\nvar graphGet = function (graphNode, _a) {\n    var _b, _c, _d;\n    var windowId = _a[0], id = _a[1], theme = _a[2];\n    return (_d = (_c = (_b = graphNode.get(windowId)) === null || _b === void 0 ? void 0 : _b.get(id)) === null || _c === void 0 ? void 0 : _c.get(theme)) === null || _d === void 0 ? void 0 : _d.classMap;\n};\nvar graphSet = function (graphNode, _a, classMap) {\n    var _b, _c;\n    var windowId = _a[0], id = _a[1], theme = _a[2];\n    var windowNode = (_b = graphNode.get(windowId)) !== null && _b !== void 0 ? _b : new Map();\n    graphNode.set(windowId, windowNode);\n    var idNode = (_c = windowNode.get(id)) !== null && _c !== void 0 ? _c : new Map();\n    windowNode.set(id, idNode);\n    idNode.set(theme, { classMap: classMap, refCount: 0 });\n};\nfunction graphRef(graphNode, _a) {\n    var _b, _c;\n    var windowId = _a[0], id = _a[1], theme = _a[2];\n    var node = (_c = (_b = graphNode.get(windowId)) === null || _b === void 0 ? void 0 : _b.get(id)) === null || _c === void 0 ? void 0 : _c.get(theme);\n    if (node) {\n        node.refCount++;\n    }\n}\nfunction graphDeref(graphNode, _a) {\n    var _b, _c, _d, _e, _f, _g, _h, _j;\n    var windowId = _a[0], id = _a[1], theme = _a[2];\n    var node = (_c = (_b = graphNode.get(windowId)) === null || _b === void 0 ? void 0 : _b.get(id)) === null || _c === void 0 ? void 0 : _c.get(theme);\n    if (node) {\n        node.refCount--;\n        if (node.refCount === 0) {\n            (_e = (_d = graphNode.get(windowId)) === null || _d === void 0 ? void 0 : _d.get(id)) === null || _e === void 0 ? void 0 : _e.delete(theme);\n            if (((_g = (_f = graphNode.get(windowId)) === null || _f === void 0 ? void 0 : _f.get(id)) === null || _g === void 0 ? void 0 : _g.size) === 0) {\n                (_h = graphNode.get(windowId)) === null || _h === void 0 ? void 0 : _h.delete(id);\n                if (((_j = graphNode.get(windowId)) === null || _j === void 0 ? void 0 : _j.size) === 0) {\n                    graphNode.delete(windowId);\n                }\n            }\n        }\n    }\n}\n/**\n * Registers a css object, optionally as a function of the theme.\n *\n * @param styleOrFunction - Either a css javascript object, or a function which takes in `ITheme`\n * and returns a css javascript object.\n *\n * @deprecated Use `mergeStyles` instead for v8 related code. We will be using a new implementation of `makeStyles` in\n * future versions of the library.\n */\nexport function makeStyles(styleOrFunction) {\n    // Create graph of inputs to map to output.\n    var graph = new Map();\n    // Retain a dictionary of window ids we're tracking\n    var allWindows = new Set();\n    // cleanupMapEntries will\n    // 1. remove all the graph branches for the window,\n    // 2. remove the event listener,\n    // 3. delete the allWindows entry.\n    var cleanupMapEntries = function (ev) {\n        var win = ev.currentTarget;\n        var winId = win.__id__;\n        graph.delete(winId);\n        win.removeEventListener('unload', cleanupMapEntries);\n        allWindows.delete(winId);\n    };\n    // eslint-disable-next-line deprecation/deprecation\n    return function (options) {\n        if (options === void 0) { options = {}; }\n        var theme = options.theme;\n        var winId;\n        var win = useWindow();\n        if (win) {\n            win.__id__ = win.__id__ || getId();\n            winId = win.__id__;\n            if (!allWindows.has(winId)) {\n                allWindows.add(winId);\n                win.addEventListener('unload', cleanupMapEntries);\n            }\n        }\n        var contextualTheme = useTheme();\n        theme = theme || contextualTheme;\n        var renderer = mergeStylesRenderer;\n        var id = renderer.getId();\n        var path = [winId, id, theme];\n        var value = graphGet(graph, path);\n        // Don't keep around unused styles\n        useEffect(function () {\n            graphRef(graph, [winId, id, theme]);\n            return function () { return graphDeref(graph, [winId, id, theme]); };\n        }, [winId, id, theme]);\n        if (!value) {\n            var styles = isStyleFunction(styleOrFunction)\n                ? styleOrFunction(theme)\n                : styleOrFunction;\n            value = mergeStylesRenderer.renderStyles(styles, { targetWindow: win, rtl: !!theme.rtl });\n            graphSet(graph, path, value);\n        }\n        return value;\n    };\n}\nfunction isStyleFunction(styleOrFunction) {\n    return typeof styleOrFunction === 'function';\n}\n//# sourceMappingURL=makeStyles.js.map","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { CustomizerContext, FocusRectsProvider, getNativeElementProps, omit } from '@fluentui/utilities';\nimport { ThemeContext } from './ThemeContext';\nexport var renderThemeProvider = function (state) {\n    var customizerContext = state.customizerContext, ref = state.ref, theme = state.theme;\n    var Root = state.as || 'div';\n    var rootProps = typeof state.as === 'string'\n        ? getNativeElementProps(state.as, state)\n        : state.as === React.Fragment\n            ? { children: state.children }\n            : omit(state, ['as']);\n    return (React.createElement(ThemeContext.Provider, { value: theme },\n        React.createElement(CustomizerContext.Provider, { value: customizerContext },\n            React.createElement(FocusRectsProvider, { providerRef: ref },\n                React.createElement(Root, __assign({}, rootProps))))));\n};\n//# sourceMappingURL=renderThemeProvider.js.map","import { mergeThemes } from '@fluentui/theme';\nimport * as React from 'react';\nimport { useTheme } from './useTheme';\nimport { getId } from '@fluentui/utilities';\nvar themeToIdMap = new Map();\nvar getThemeId = function () {\n    var themes = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        themes[_i] = arguments[_i];\n    }\n    var ids = [];\n    for (var _a = 0, themes_1 = themes; _a < themes_1.length; _a++) {\n        var theme = themes_1[_a];\n        if (theme) {\n            var id = theme.id || themeToIdMap.get(theme);\n            if (!id) {\n                id = getId('');\n                themeToIdMap.set(theme, id);\n            }\n            ids.push(id);\n        }\n    }\n    return ids.join('-');\n};\nexport var useThemeProviderState = function (draftState) {\n    var userTheme = draftState.theme;\n    // Pull contextual theme.\n    var parentTheme = useTheme();\n    // Update the incoming theme with a memoized version of the merged theme.\n    var theme = (draftState.theme = React.useMemo(function () {\n        var mergedTheme = mergeThemes(parentTheme, userTheme);\n        mergedTheme.id = getThemeId(parentTheme, userTheme);\n        return mergedTheme;\n    }, [parentTheme, userTheme]));\n    draftState.customizerContext = React.useMemo(function () { return ({\n        customizations: {\n            inCustomizerContext: true,\n            settings: { theme: theme },\n            scopedSettings: theme.components || {},\n        },\n    }); }, [theme]);\n    if (draftState.theme.rtl !== parentTheme.rtl) {\n        draftState.dir = draftState.theme.rtl ? 'rtl' : 'ltr';\n    }\n};\n//# sourceMappingURL=useThemeProviderState.js.map","import * as React from 'react';\nimport { useThemeProviderClasses } from './useThemeProviderClasses';\nimport { useThemeProvider } from './useThemeProvider';\nimport { useMergedRefs } from '@fluentui/react-hooks';\n/**\n * ThemeProvider, used for providing css variables and registering stylesheets.\n */\nexport var ThemeProvider = React.forwardRef(function (props, ref) {\n    var rootRef = useMergedRefs(ref, React.useRef(null));\n    var _a = useThemeProvider(props, {\n        ref: rootRef,\n        as: 'div',\n        applyTo: 'element',\n    }), render = _a.render, state = _a.state;\n    // Render styles.\n    useThemeProviderClasses(state);\n    // Return the rendered content.\n    return render(state);\n});\nThemeProvider.displayName = 'ThemeProvider';\n//# sourceMappingURL=ThemeProvider.js.map","import { renderThemeProvider as render } from './renderThemeProvider';\nimport { useThemeProviderState } from './useThemeProviderState';\nimport { getPropsWithDefaults } from '@fluentui/utilities';\n/**\n * Returns the ThemeProvider render function and calculated state, given user input, ref, and\n * a set of default prop values.\n */\nexport var useThemeProvider = function (props, defaultProps) {\n    var state = getPropsWithDefaults(defaultProps, props);\n    // Apply changes to state.\n    useThemeProviderState(state);\n    return {\n        state: state,\n        render: render,\n    };\n};\n//# sourceMappingURL=useThemeProvider.js.map","import { useContext } from 'react';\nimport { useCustomizationSettings } from '@fluentui/utilities';\nimport { createTheme } from '@fluentui/theme';\nimport { ThemeContext } from './ThemeContext';\n/**\n * Get theme from CustomizerContext or Customizations singleton.\n */\nfunction useCompatTheme() {\n    return useCustomizationSettings(['theme']).theme;\n}\n/**\n * React hook for programmatically accessing the theme.\n */\nexport var useTheme = function () {\n    var theme = useContext(ThemeContext);\n    var legacyTheme = useCompatTheme();\n    return theme || legacyTheme || createTheme({});\n};\n//# sourceMappingURL=useTheme.js.map","/**\n * Determines the effective checked state of a menu item.\n *\n * @param item {IContextualMenuItem} to get the check state of.\n * @returns {true} if the item is checked.\n * @returns {false} if the item is unchecked.\n * @returns {null} if the item is not checkable.\n */\nexport function getIsChecked(item) {\n    if (item.canCheck) {\n        return !!(item.isChecked || item.checked);\n    }\n    if (typeof item.isChecked === 'boolean') {\n        return item.isChecked;\n    }\n    if (typeof item.checked === 'boolean') {\n        return item.checked;\n    }\n    // Item is not checkable.\n    return null;\n}\nexport function hasSubmenu(item) {\n    // eslint-disable-next-line deprecation/deprecation\n    return !!(item.subMenuProps || item.items);\n}\nexport function isItemDisabled(item) {\n    return !!(item.isDisabled || item.disabled);\n}\nexport function getMenuItemAriaRole(item) {\n    var isChecked = getIsChecked(item);\n    var canCheck = isChecked !== null;\n    return canCheck ? 'menuitemcheckbox' : 'menuitem';\n}\n//# sourceMappingURL=contextualMenuUtility.js.map","import { __assign, __extends } from \"tslib\";\nimport * as React from 'react';\nimport { BaseDecorator } from './BaseDecorator';\nimport { getWindow, hoistStatics, EventGroup } from '../../Utilities';\nimport { WindowContext } from '../../WindowProvider';\nexport var ResponsiveMode;\n(function (ResponsiveMode) {\n    /** Width \\<= 479px */\n    ResponsiveMode[ResponsiveMode[\"small\"] = 0] = \"small\";\n    /** Width \\> 479px and \\<= 639px */\n    ResponsiveMode[ResponsiveMode[\"medium\"] = 1] = \"medium\";\n    /** Width \\> 639px and \\<= 1023px */\n    ResponsiveMode[ResponsiveMode[\"large\"] = 2] = \"large\";\n    /** Width \\> 1023px and \\<= 1365px */\n    ResponsiveMode[ResponsiveMode[\"xLarge\"] = 3] = \"xLarge\";\n    /** Width \\> 1365px and \\<= 1919px */\n    ResponsiveMode[ResponsiveMode[\"xxLarge\"] = 4] = \"xxLarge\";\n    /** Width \\> 1919px */\n    ResponsiveMode[ResponsiveMode[\"xxxLarge\"] = 5] = \"xxxLarge\";\n    ResponsiveMode[ResponsiveMode[\"unknown\"] = 999] = \"unknown\";\n})(ResponsiveMode || (ResponsiveMode = {}));\nvar RESPONSIVE_MAX_CONSTRAINT = [479, 639, 1023, 1365, 1919, 99999999];\n/**\n * User specified mode to default to, useful for server side rendering scenarios.\n */\nvar _defaultMode;\n/**\n * Tracking the last mode we successfully rendered, which allows us to\n * paint initial renders with the correct size.\n */\nvar _lastMode;\n/**\n * Allows a server rendered scenario to provide a **default** responsive mode.\n * This WILL NOT trigger any updates to components that have already consumed the responsive mode!\n */\nexport function setResponsiveMode(responsiveMode) {\n    _defaultMode = responsiveMode;\n}\n/**\n * Initializes the responsive mode to the current window size. This can be used to avoid\n * a re-render during first component mount since the window would otherwise not be measured\n * until after mounting.\n *\n * This WILL NOT trigger any updates to components that have already consumed the responsive mode!\n */\nexport function initializeResponsiveMode(element) {\n    var currentWindow = getWindow(element);\n    if (currentWindow) {\n        getResponsiveMode(currentWindow);\n    }\n}\nexport function getInitialResponsiveMode() {\n    var _a;\n    return (_a = _defaultMode !== null && _defaultMode !== void 0 ? _defaultMode : _lastMode) !== null && _a !== void 0 ? _a : ResponsiveMode.large;\n}\n/**\n * @deprecated Decorator usage is deprecated. Either call `getResponsiveMode` manually, or\n * use the `useResponsiveMode` hook within a function component.\n */\nexport function withResponsiveMode(ComposedComponent) {\n    var _a;\n    // eslint-disable-next-line deprecation/deprecation\n    var resultClass = (_a = /** @class */ (function (_super) {\n            __extends(WithResponsiveMode, _super);\n            function WithResponsiveMode(props) {\n                var _this = _super.call(this, props) || this;\n                _this._onResize = function () {\n                    var responsiveMode = getResponsiveMode(_this.context.window);\n                    if (responsiveMode !== _this.state.responsiveMode) {\n                        _this.setState({\n                            responsiveMode: responsiveMode,\n                        });\n                    }\n                };\n                _this._events = new EventGroup(_this);\n                _this._updateComposedComponentRef = _this._updateComposedComponentRef.bind(_this);\n                _this.state = {\n                    responsiveMode: getInitialResponsiveMode(),\n                };\n                return _this;\n            }\n            WithResponsiveMode.prototype.componentDidMount = function () {\n                this._events.on(this.context.window, 'resize', this._onResize);\n                this._onResize();\n            };\n            WithResponsiveMode.prototype.componentWillUnmount = function () {\n                this._events.dispose();\n            };\n            WithResponsiveMode.prototype.render = function () {\n                var responsiveMode = this.state.responsiveMode;\n                return responsiveMode === ResponsiveMode.unknown ? null : (React.createElement(ComposedComponent, __assign({ ref: this._updateComposedComponentRef, responsiveMode: responsiveMode }, this.props)));\n            };\n            return WithResponsiveMode;\n        }(BaseDecorator)),\n        _a.contextType = WindowContext,\n        _a);\n    return hoistStatics(ComposedComponent, resultClass);\n}\nfunction getWidthOfCurrentWindow(currentWindow) {\n    try {\n        return currentWindow.document.documentElement.clientWidth;\n    }\n    catch (e) {\n        return currentWindow.innerWidth;\n    }\n}\n/**\n * Hook to get the current responsive mode (window size category).\n * @param currentWindow - Use this window when determining the responsive mode.\n */\nexport function getResponsiveMode(currentWindow) {\n    var responsiveMode = ResponsiveMode.small;\n    if (currentWindow) {\n        try {\n            while (getWidthOfCurrentWindow(currentWindow) > RESPONSIVE_MAX_CONSTRAINT[responsiveMode]) {\n                responsiveMode++;\n            }\n        }\n        catch (e) {\n            // Return a best effort result in cases where we're in the browser but it throws on getting innerWidth.\n            responsiveMode = getInitialResponsiveMode();\n        }\n        // Tracking last mode just gives us a better default in future renders,\n        // which avoids starting with the wrong value if we've measured once.\n        _lastMode = responsiveMode;\n    }\n    else {\n        if (_defaultMode !== undefined) {\n            responsiveMode = _defaultMode;\n        }\n        else {\n            throw new Error('Content was rendered in a server environment without providing a default responsive mode. ' +\n                'Call setResponsiveMode to define what the responsive mode is.');\n        }\n    }\n    return responsiveMode;\n}\n//# sourceMappingURL=withResponsiveMode.js.map","import * as React from 'react';\nimport { getWindow } from '@fluentui/utilities';\nimport { useOnEvent } from '@fluentui/react-hooks';\nimport { getResponsiveMode, getInitialResponsiveMode } from '../decorators/withResponsiveMode';\nimport { useWindow } from '../../WindowProvider';\n/**\n * Hook to get the current responsive mode (window size category).\n * @param elementRef - Use this element's parent window when determining the responsive mode.\n * @param overrideResponsiveMode - Override the responsive mode. If this param is present, it's always returned.\n */\nexport var useResponsiveMode = function (elementRef, overrideResponsiveMode) {\n    var _a = React.useState(getInitialResponsiveMode()), lastResponsiveMode = _a[0], setLastResponsiveMode = _a[1];\n    var onResize = React.useCallback(function () {\n        var newResponsiveMode = getResponsiveMode(getWindow(elementRef.current));\n        // Setting the same value should not cause a re-render.\n        if (lastResponsiveMode !== newResponsiveMode) {\n            setLastResponsiveMode(newResponsiveMode);\n        }\n    }, [elementRef, lastResponsiveMode]);\n    var win = useWindow();\n    useOnEvent(win, 'resize', onResize);\n    // Call resize function initially on mount, or if the override changes from defined to undefined\n    // (the effect will run on all override changes, but onResize will only be called if it changed to undefined)\n    React.useEffect(function () {\n        if (overrideResponsiveMode === undefined) {\n            onResize();\n        }\n        // eslint-disable-next-line react-hooks/exhaustive-deps -- only meant to run on mount or when override changes\n    }, [overrideResponsiveMode]);\n    return overrideResponsiveMode !== null && overrideResponsiveMode !== void 0 ? overrideResponsiveMode : lastResponsiveMode;\n};\n//# sourceMappingURL=useResponsiveMode.js.map","export var KTP_PREFIX = 'ktp';\nexport var KTP_SEPARATOR = '-';\nexport var KTP_FULL_PREFIX = KTP_PREFIX + KTP_SEPARATOR;\nexport var DATAKTP_TARGET = 'data-ktp-target';\nexport var DATAKTP_EXECUTE_TARGET = 'data-ktp-execute-target';\nexport var DATAKTP_ARIA_TARGET = 'data-ktp-aria-target';\nexport var KTP_LAYER_ID = 'ktp-layer-id';\nexport var KTP_ARIA_SEPARATOR = ', ';\n// Events\nexport var KeytipEvents;\n(function (KeytipEvents) {\n    KeytipEvents.KEYTIP_ADDED = 'keytipAdded';\n    KeytipEvents.KEYTIP_REMOVED = 'keytipRemoved';\n    KeytipEvents.KEYTIP_UPDATED = 'keytipUpdated';\n    KeytipEvents.PERSISTED_KEYTIP_ADDED = 'persistedKeytipAdded';\n    KeytipEvents.PERSISTED_KEYTIP_REMOVED = 'persistedKeytipRemoved';\n    KeytipEvents.PERSISTED_KEYTIP_EXECUTE = 'persistedKeytipExecute';\n    KeytipEvents.ENTER_KEYTIP_MODE = 'enterKeytipMode';\n    KeytipEvents.EXIT_KEYTIP_MODE = 'exitKeytipMode';\n})(KeytipEvents || (KeytipEvents = {}));\n//# sourceMappingURL=KeytipConstants.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { EventGroup, getId } from '../../Utilities';\nimport { KeytipEvents } from '../../utilities/keytips/KeytipConstants';\n/**\n * This class is responsible for handling registering, updating, and unregistering of keytips\n */\nvar KeytipManager = /** @class */ (function () {\n    function KeytipManager() {\n        this.keytips = {};\n        this.persistedKeytips = {};\n        this.sequenceMapping = {};\n        // This is (and should be) updated and kept in sync\n        // with the inKeytipMode in KeytipLayer.\n        this.inKeytipMode = false;\n        // Boolean that gets checked before entering keytip mode by the KeytipLayer\n        // Used for an override in special cases (e.g. Disable entering keytip mode when a modal is shown)\n        this.shouldEnterKeytipMode = true;\n        // Boolean to indicate whether to delay firing an event to update subscribers of\n        // keytip data changed.\n        this.delayUpdatingKeytipChange = false;\n    }\n    /**\n     * Static function to get singleton KeytipManager instance\n     *\n     * @returns Singleton KeytipManager instance\n     */\n    KeytipManager.getInstance = function () {\n        return this._instance;\n    };\n    /**\n     * Initialization code to set set parameters to define\n     * how the KeytipManager handles keytip data.\n     *\n     * @param delayUpdatingKeytipChange - T/F if we should delay notifiying keytip subscribers\n     * of keytip changes\n     */\n    KeytipManager.prototype.init = function (delayUpdatingKeytipChange) {\n        this.delayUpdatingKeytipChange = delayUpdatingKeytipChange;\n    };\n    /**\n     * Registers a keytip\n     *\n     * @param keytipProps - Keytip to register\n     * @param persisted - T/F if this keytip should be persisted, default is false\n     * @returns Unique ID for this keytip\n     */\n    KeytipManager.prototype.register = function (keytipProps, persisted) {\n        if (persisted === void 0) { persisted = false; }\n        var props = keytipProps;\n        if (!persisted) {\n            // Add the overflowSetSequence if necessary\n            props = this.addParentOverflow(keytipProps);\n            this.sequenceMapping[props.keySequences.toString()] = props;\n        }\n        // Create a unique keytip\n        var uniqueKeytip = this._getUniqueKtp(props);\n        // Add to dictionary\n        persisted\n            ? (this.persistedKeytips[uniqueKeytip.uniqueID] = uniqueKeytip)\n            : (this.keytips[uniqueKeytip.uniqueID] = uniqueKeytip);\n        // We only want to add something new if we are currently showing keytip mode\n        if (this.inKeytipMode || !this.delayUpdatingKeytipChange) {\n            var event_1 = persisted ? KeytipEvents.PERSISTED_KEYTIP_ADDED : KeytipEvents.KEYTIP_ADDED;\n            EventGroup.raise(this, event_1, {\n                keytip: props,\n                uniqueID: uniqueKeytip.uniqueID,\n            });\n        }\n        return uniqueKeytip.uniqueID;\n    };\n    /**\n     * Update a keytip\n     *\n     * @param keytipProps - Keytip to update\n     * @param uniqueID - Unique ID of this keytip\n     */\n    KeytipManager.prototype.update = function (keytipProps, uniqueID) {\n        var newKeytipProps = this.addParentOverflow(keytipProps);\n        var uniqueKeytip = this._getUniqueKtp(newKeytipProps, uniqueID);\n        var oldKeyTip = this.keytips[uniqueID];\n        if (oldKeyTip) {\n            // Update everything except 'visible'\n            uniqueKeytip.keytip.visible = oldKeyTip.keytip.visible;\n            // Update keytip in this.keytips\n            this.keytips[uniqueID] = uniqueKeytip;\n            // Update the sequence to be up to date\n            delete this.sequenceMapping[oldKeyTip.keytip.keySequences.toString()];\n            this.sequenceMapping[uniqueKeytip.keytip.keySequences.toString()] = uniqueKeytip.keytip;\n            // Raise event only if we are currently in keytip mode\n            if (this.inKeytipMode || !this.delayUpdatingKeytipChange) {\n                EventGroup.raise(this, KeytipEvents.KEYTIP_UPDATED, {\n                    keytip: uniqueKeytip.keytip,\n                    uniqueID: uniqueKeytip.uniqueID,\n                });\n            }\n        }\n    };\n    /**\n     * Unregisters a keytip\n     *\n     * @param keytipToRemove - IKeytipProps of the keytip to remove\n     * @param uniqueID - Unique ID of this keytip\n     * @param persisted - T/F if this keytip should be persisted, default is false\n     */\n    KeytipManager.prototype.unregister = function (keytipToRemove, uniqueID, persisted) {\n        if (persisted === void 0) { persisted = false; }\n        persisted ? delete this.persistedKeytips[uniqueID] : delete this.keytips[uniqueID];\n        !persisted && delete this.sequenceMapping[keytipToRemove.keySequences.toString()];\n        var event = persisted ? KeytipEvents.PERSISTED_KEYTIP_REMOVED : KeytipEvents.KEYTIP_REMOVED;\n        // Update keytips only if we're in keytip mode\n        if (this.inKeytipMode || !this.delayUpdatingKeytipChange) {\n            EventGroup.raise(this, event, {\n                keytip: keytipToRemove,\n                uniqueID: uniqueID,\n            });\n        }\n    };\n    /**\n     * Manual call to enter keytip mode\n     */\n    KeytipManager.prototype.enterKeytipMode = function () {\n        EventGroup.raise(this, KeytipEvents.ENTER_KEYTIP_MODE);\n    };\n    /**\n     * Manual call to exit keytip mode\n     */\n    KeytipManager.prototype.exitKeytipMode = function () {\n        EventGroup.raise(this, KeytipEvents.EXIT_KEYTIP_MODE);\n    };\n    /**\n     * Gets all IKeytipProps from this.keytips\n     *\n     * @returns All keytips stored in the manager\n     */\n    KeytipManager.prototype.getKeytips = function () {\n        var _this = this;\n        return Object.keys(this.keytips).map(function (key) { return _this.keytips[key].keytip; });\n    };\n    /**\n     * Adds the overflowSetSequence to the keytipProps if its parent keytip also has it\n     *\n     * @param keytipProps - Keytip props to add overflowSetSequence to if necessary\n     * @returns - Modified keytip props, if needed to be modified\n     */\n    KeytipManager.prototype.addParentOverflow = function (keytipProps) {\n        var fullSequence = __spreadArray([], keytipProps.keySequences, true);\n        fullSequence.pop();\n        if (fullSequence.length !== 0) {\n            var parentKeytip = this.sequenceMapping[fullSequence.toString()];\n            if (parentKeytip && parentKeytip.overflowSetSequence) {\n                return __assign(__assign({}, keytipProps), { overflowSetSequence: parentKeytip.overflowSetSequence });\n            }\n        }\n        return keytipProps;\n    };\n    /**\n     * Public function to bind for overflow items that have a submenu\n     */\n    KeytipManager.prototype.menuExecute = function (overflowButtonSequences, keytipSequences) {\n        EventGroup.raise(this, KeytipEvents.PERSISTED_KEYTIP_EXECUTE, {\n            overflowButtonSequences: overflowButtonSequences,\n            keytipSequences: keytipSequences,\n        });\n    };\n    /**\n     * Creates an IUniqueKeytip object\n     *\n     * @param keytipProps - IKeytipProps\n     * @param uniqueID - Unique ID, will default to the next unique ID if not passed\n     * @returns IUniqueKeytip object\n     */\n    KeytipManager.prototype._getUniqueKtp = function (keytipProps, uniqueID) {\n        if (uniqueID === void 0) { uniqueID = getId(); }\n        return { keytip: __assign({}, keytipProps), uniqueID: uniqueID };\n    };\n    KeytipManager._instance = new KeytipManager();\n    return KeytipManager;\n}());\nexport { KeytipManager };\n//# sourceMappingURL=KeytipManager.js.map","import { __spreadArray } from \"tslib\";\nimport { KTP_SEPARATOR, KTP_PREFIX, DATAKTP_TARGET, DATAKTP_EXECUTE_TARGET, KTP_LAYER_ID } from './KeytipConstants';\nimport { addElementAtIndex } from '../../Utilities';\n/**\n * Converts a whole set of KeySequences into one keytip ID, which will be the ID for the last keytip sequence specified\n * keySequences should not include the initial keytip 'start' sequence.\n *\n * @param keySequences - Full path of IKeySequences for one keytip.\n * @returns String to use for the keytip ID.\n */\nexport function sequencesToID(keySequences) {\n    return keySequences.reduce(function (prevValue, keySequence) {\n        return prevValue + KTP_SEPARATOR + keySequence.split('').join(KTP_SEPARATOR);\n    }, KTP_PREFIX);\n}\n/**\n * Merges an overflow sequence with a key sequence.\n *\n * @param keySequences - Full sequence for one keytip.\n * @param overflowKeySequences - Full overflow keytip sequence.\n * @returns Sequence that will be used by the keytip when in the overflow.\n */\nexport function mergeOverflows(keySequences, overflowKeySequences) {\n    var overflowSequenceLen = overflowKeySequences.length;\n    var overflowSequence = __spreadArray([], overflowKeySequences, true).pop();\n    var newKeySequences = __spreadArray([], keySequences, true);\n    return addElementAtIndex(newKeySequences, overflowSequenceLen - 1, overflowSequence);\n}\n/**\n * Constructs the data-ktp-target attribute selector from a full key sequence.\n *\n * @param keySequences - Full string[] for a Keytip.\n * @returns String selector to use to query for the keytip target.\n */\nexport function ktpTargetFromSequences(keySequences) {\n    return '[' + DATAKTP_TARGET + '=\"' + sequencesToID(keySequences) + '\"]';\n}\n/**\n * Constructs the data-ktp-execute-target attribute selector from a keytip ID.\n *\n * @param keytipId - ID of the Keytip.\n * @returns String selector to use to query for the keytip execute target.\n */\nexport function ktpTargetFromId(keytipId) {\n    return '[' + DATAKTP_EXECUTE_TARGET + '=\"' + keytipId + '\"]';\n}\n/**\n * Gets the aria-describedby value to put on the component with this keytip.\n *\n * @param keySequences - KeySequences of the keytip.\n * @returns The aria-describedby value to set on the component with this keytip.\n */\nexport function getAriaDescribedBy(keySequences) {\n    var describedby = ' ' + KTP_LAYER_ID;\n    if (!keySequences.length) {\n        // Return just the layer ID\n        return describedby;\n    }\n    return describedby + ' ' + sequencesToID(keySequences);\n}\n//# sourceMappingURL=KeytipUtils.js.map","var _a;\nimport { __assign } from \"tslib\";\nimport { DirectionalHint } from '../../common/DirectionalHint';\nimport { getScrollbarWidth, getRTL } from '../../Utilities';\nimport { RectangleEdge } from './positioning.types';\nimport { Rectangle } from '../../Utilities';\nfunction _createPositionData(targetEdge, alignmentEdge, isAuto) {\n    return {\n        targetEdge: targetEdge,\n        alignmentEdge: alignmentEdge,\n        isAuto: isAuto,\n    };\n}\n// Currently the beakPercent is set to 50 for all positions meaning that it should tend to the center of the target\nvar DirectionalDictionary = (_a = {},\n    _a[DirectionalHint.topLeftEdge] = _createPositionData(RectangleEdge.top, RectangleEdge.left),\n    _a[DirectionalHint.topCenter] = _createPositionData(RectangleEdge.top),\n    _a[DirectionalHint.topRightEdge] = _createPositionData(RectangleEdge.top, RectangleEdge.right),\n    _a[DirectionalHint.topAutoEdge] = _createPositionData(RectangleEdge.top, undefined, true),\n    _a[DirectionalHint.bottomLeftEdge] = _createPositionData(RectangleEdge.bottom, RectangleEdge.left),\n    _a[DirectionalHint.bottomCenter] = _createPositionData(RectangleEdge.bottom),\n    _a[DirectionalHint.bottomRightEdge] = _createPositionData(RectangleEdge.bottom, RectangleEdge.right),\n    _a[DirectionalHint.bottomAutoEdge] = _createPositionData(RectangleEdge.bottom, undefined, true),\n    _a[DirectionalHint.leftTopEdge] = _createPositionData(RectangleEdge.left, RectangleEdge.top),\n    _a[DirectionalHint.leftCenter] = _createPositionData(RectangleEdge.left),\n    _a[DirectionalHint.leftBottomEdge] = _createPositionData(RectangleEdge.left, RectangleEdge.bottom),\n    _a[DirectionalHint.rightTopEdge] = _createPositionData(RectangleEdge.right, RectangleEdge.top),\n    _a[DirectionalHint.rightCenter] = _createPositionData(RectangleEdge.right),\n    _a[DirectionalHint.rightBottomEdge] = _createPositionData(RectangleEdge.right, RectangleEdge.bottom),\n    _a);\nfunction _isRectangleWithinBounds(rect, boundingRect) {\n    if (rect.top < boundingRect.top) {\n        return false;\n    }\n    if (rect.bottom > boundingRect.bottom) {\n        return false;\n    }\n    if (rect.left < boundingRect.left) {\n        return false;\n    }\n    if (rect.right > boundingRect.right) {\n        return false;\n    }\n    return true;\n}\n/**\n * Gets all of the edges of a rectangle that are outside of the given bounds.\n * If there are no out of bounds edges it returns an empty array.\n */\nfunction _getOutOfBoundsEdges(rect, boundingRect) {\n    var outOfBounds = [];\n    if (rect.top < boundingRect.top) {\n        outOfBounds.push(RectangleEdge.top);\n    }\n    if (rect.bottom > boundingRect.bottom) {\n        outOfBounds.push(RectangleEdge.bottom);\n    }\n    if (rect.left < boundingRect.left) {\n        outOfBounds.push(RectangleEdge.left);\n    }\n    if (rect.right > boundingRect.right) {\n        outOfBounds.push(RectangleEdge.right);\n    }\n    return outOfBounds;\n}\nfunction _getEdgeValue(rect, edge) {\n    return rect[RectangleEdge[edge]];\n}\nfunction _setEdgeValue(rect, edge, value) {\n    rect[RectangleEdge[edge]] = value;\n    return rect;\n}\n/**\n * Returns the middle value of an edge. Only returns 1 value rather than xy coordinates as\n * the itself already contains the other coordinate.\n * For instance, a bottom edge's current value is it's y coordinate, so the number returned is the x.\n */\nfunction _getCenterValue(rect, edge) {\n    var edges = _getFlankingEdges(edge);\n    return (_getEdgeValue(rect, edges.positiveEdge) + _getEdgeValue(rect, edges.negativeEdge)) / 2;\n}\n/**\n * Flips the value depending on the edge.\n * If the edge is a \"positive\" edge, Top or Left, then the value should stay as it is.\n * If the edge is a \"negative\" edge, Bottom or Right, then the value should be flipped.\n * This is to account for the fact that the coordinates are effectively reserved in certain cases for the\n * \"negative\" edges.\n *\n * For example, when testing to see if a bottom edge 1 is within the bounds of another bottom edge 2:\n * If edge 1 is greater than edge 2 then it is out of bounds. This is reversed for top edge 1 and top edge 2.\n * If top edge 1 is less than edge 2 then it is out of bounds.\n */\nfunction _getRelativeEdgeValue(edge, value) {\n    if (edge > 0) {\n        return value;\n    }\n    else {\n        return value * -1;\n    }\n}\nfunction _getRelativeRectEdgeValue(edge, rect) {\n    return _getRelativeEdgeValue(edge, _getEdgeValue(rect, edge));\n}\nfunction _getRelativeEdgeDifference(rect, hostRect, edge) {\n    var edgeDifference = _getEdgeValue(rect, edge) - _getEdgeValue(hostRect, edge);\n    return _getRelativeEdgeValue(edge, edgeDifference);\n}\n/**\n * Moves the edge of a rectangle to the value given. It only moves the edge in a linear direction based on that edge.\n * For example, if it's a bottom edge it will only change y coordinates.\n * if maintainSize is set to false, it will only adjust the specified edge value\n */\nfunction _moveEdge(rect, edge, newValue, maintainSize) {\n    if (maintainSize === void 0) { maintainSize = true; }\n    var difference = _getEdgeValue(rect, edge) - newValue;\n    var returnRect = _setEdgeValue(rect, edge, newValue);\n    if (maintainSize) {\n        returnRect = _setEdgeValue(rect, edge * -1, _getEdgeValue(rect, edge * -1) - difference);\n    }\n    return returnRect;\n}\n/**\n * Aligns the edge on the passed in rect to the target. If there is a gap then it will have that space between the two.\n */\nfunction _alignEdges(rect, target, edge, gap) {\n    if (gap === void 0) { gap = 0; }\n    return _moveEdge(rect, edge, _getEdgeValue(target, edge) + _getRelativeEdgeValue(edge, gap));\n}\n/**\n * Aligns the targetEdge on the passed in target to the rects corresponding opposite edge.\n * For instance if targetEdge is bottom, then the rects top will be moved to match it.\n */\nfunction _alignOppositeEdges(rect, target, targetEdge, gap) {\n    if (gap === void 0) { gap = 0; }\n    var oppositeEdge = targetEdge * -1;\n    var adjustedGap = _getRelativeEdgeValue(oppositeEdge, gap);\n    return _moveEdge(rect, targetEdge * -1, _getEdgeValue(target, targetEdge) + adjustedGap);\n}\n/**\n * Tests to see if the given edge is within the bounds of the given rectangle.\n */\nfunction _isEdgeInBounds(rect, bounds, edge) {\n    var adjustedRectValue = _getRelativeRectEdgeValue(edge, rect);\n    return adjustedRectValue > _getRelativeRectEdgeValue(edge, bounds);\n}\n/**\n * Returns a measure of how much a rectangle is out of bounds for a given alignment;\n * this can be used to compare which rectangle is more or less out of bounds.\n * A value of 0 means the rectangle is entirely in bounds\n */\nfunction _getOutOfBoundsDegree(rect, bounds) {\n    var breakingEdges = _getOutOfBoundsEdges(rect, bounds);\n    var total = 0;\n    for (var _i = 0, breakingEdges_1 = breakingEdges; _i < breakingEdges_1.length; _i++) {\n        var edge = breakingEdges_1[_i];\n        total += Math.pow(_getRelativeEdgeDifference(rect, bounds, edge), 2);\n    }\n    return total;\n}\n/**\n * Attempts to move the rectangle through various sides of the target to find a place to fit.\n * If no fit is found, the least bad option should be returned.\n */\nfunction _flipToFit(rect, target, bounding, positionData, gap) {\n    if (gap === void 0) { gap = 0; }\n    var directions = [\n        RectangleEdge.left,\n        RectangleEdge.right,\n        RectangleEdge.bottom,\n        RectangleEdge.top,\n    ];\n    // In RTL page, RectangleEdge.right has a higher priority than RectangleEdge.left, so the order should be updated.\n    if (getRTL()) {\n        directions[0] *= -1;\n        directions[1] *= -1;\n    }\n    var currentEstimate = rect;\n    var currentEdge = positionData.targetEdge;\n    var currentAlignment = positionData.alignmentEdge;\n    // keep track of least bad option, in case no sides fit\n    var oobDegree;\n    var bestEdge = currentEdge;\n    var bestAlignment = currentAlignment;\n    // Keep switching sides until one is found with enough space.\n    // If all sides don't fit then return the unmodified element.\n    for (var i = 0; i < 4; i++) {\n        if (!_isEdgeInBounds(currentEstimate, bounding, currentEdge)) {\n            // update least-bad edges\n            var currentOOBDegree = _getOutOfBoundsDegree(currentEstimate, bounding);\n            if (!oobDegree || currentOOBDegree < oobDegree) {\n                oobDegree = currentOOBDegree;\n                bestEdge = currentEdge;\n                bestAlignment = currentAlignment;\n            }\n            directions.splice(directions.indexOf(currentEdge), 1);\n            if (directions.length > 0) {\n                if (directions.indexOf(currentEdge * -1) > -1) {\n                    currentEdge = currentEdge * -1;\n                }\n                else {\n                    currentAlignment = currentEdge;\n                    currentEdge = directions.slice(-1)[0];\n                }\n                currentEstimate = _estimatePosition(rect, target, { targetEdge: currentEdge, alignmentEdge: currentAlignment }, gap);\n            }\n        }\n        else {\n            return {\n                elementRectangle: currentEstimate,\n                targetEdge: currentEdge,\n                alignmentEdge: currentAlignment,\n            };\n        }\n    }\n    // nothing fits, use least-bad option\n    currentEstimate = _estimatePosition(rect, target, { targetEdge: bestEdge, alignmentEdge: bestAlignment }, gap);\n    return {\n        elementRectangle: currentEstimate,\n        targetEdge: bestEdge,\n        alignmentEdge: bestAlignment,\n    };\n}\n/**\n * Flips only the alignment edge of an element rectangle. This is used instead of nudging the alignment edges\n * into position, when `alignTargetEdge` is specified.\n */\nfunction _flipAlignmentEdge(elementEstimate, target, gap, coverTarget) {\n    var alignmentEdge = elementEstimate.alignmentEdge, targetEdge = elementEstimate.targetEdge, elementRectangle = elementEstimate.elementRectangle;\n    var oppositeEdge = alignmentEdge * -1;\n    var newEstimate = _estimatePosition(elementRectangle, target, { targetEdge: targetEdge, alignmentEdge: oppositeEdge }, gap, coverTarget);\n    return {\n        elementRectangle: newEstimate,\n        targetEdge: targetEdge,\n        alignmentEdge: oppositeEdge,\n    };\n}\n/**\n * Adjusts a element rectangle to fit within the bounds given. If directionalHintFixed or covertarget is passed in\n * then the element will not flip sides on the target. They will, however, be nudged to fit within the bounds given.\n */\nfunction _adjustFitWithinBounds(element, target, bounding, positionData, gap, directionalHintFixed, coverTarget) {\n    if (gap === void 0) { gap = 0; }\n    var alignmentEdge = positionData.alignmentEdge, alignTargetEdge = positionData.alignTargetEdge;\n    var elementEstimate = {\n        elementRectangle: element,\n        targetEdge: positionData.targetEdge,\n        alignmentEdge: alignmentEdge,\n    };\n    if (!directionalHintFixed && !coverTarget) {\n        elementEstimate = _flipToFit(element, target, bounding, positionData, gap);\n    }\n    var outOfBounds = _getOutOfBoundsEdges(elementEstimate.elementRectangle, bounding);\n    // if directionalHintFixed is specified, we need to force the target edge to not change\n    // we need *-1 because targetEdge refers to the target's edge; the callout edge is the opposite\n    var fixedEdge = directionalHintFixed ? -elementEstimate.targetEdge : undefined;\n    if (outOfBounds.length > 0) {\n        if (alignTargetEdge) {\n            // The edge opposite to the alignment edge might be out of bounds.\n            // Flip alignment to see if we can get it within bounds.\n            if (elementEstimate.alignmentEdge && outOfBounds.indexOf(elementEstimate.alignmentEdge * -1) > -1) {\n                var flippedElementEstimate = _flipAlignmentEdge(elementEstimate, target, gap, coverTarget);\n                if (_isRectangleWithinBounds(flippedElementEstimate.elementRectangle, bounding)) {\n                    return flippedElementEstimate;\n                }\n                else {\n                    // If the flipped elements edges are still out of bounds, try nudging it.\n                    elementEstimate = _alignOutOfBoundsEdges(_getOutOfBoundsEdges(flippedElementEstimate.elementRectangle, bounding), elementEstimate, bounding, fixedEdge);\n                }\n            }\n            else {\n                elementEstimate = _alignOutOfBoundsEdges(outOfBounds, elementEstimate, bounding, fixedEdge);\n            }\n        }\n        else {\n            elementEstimate = _alignOutOfBoundsEdges(outOfBounds, elementEstimate, bounding, fixedEdge);\n        }\n    }\n    return elementEstimate;\n}\n/**\n * Iterates through a list of out of bounds edges and tries to nudge and align them.\n * @param outOfBoundsEdges - Array of edges that are out of bounds\n * @param elementEstimate - The current element positioning estimate\n * @param bounding - The current bounds\n * @param preserveEdge - Specify an edge that should not be modified\n */\nfunction _alignOutOfBoundsEdges(outOfBoundsEdges, elementEstimate, bounding, preserveEdge) {\n    for (var _i = 0, outOfBoundsEdges_1 = outOfBoundsEdges; _i < outOfBoundsEdges_1.length; _i++) {\n        var direction = outOfBoundsEdges_1[_i];\n        var edgeAttempt = void 0;\n        // if preserveEdge is specified, do not call _alignEdges, skip directly to _moveEdge\n        // this is because _alignEdges will move the opposite edge\n        if (preserveEdge && preserveEdge === direction * -1) {\n            edgeAttempt = _moveEdge(elementEstimate.elementRectangle, direction, _getEdgeValue(bounding, direction), false);\n            elementEstimate.forcedInBounds = true;\n        }\n        else {\n            edgeAttempt = _alignEdges(elementEstimate.elementRectangle, bounding, direction);\n            var inBounds = _isEdgeInBounds(edgeAttempt, bounding, direction * -1);\n            // only update estimate if the attempt didn't break out of the opposite bounding edge\n            if (!inBounds) {\n                edgeAttempt = _moveEdge(edgeAttempt, direction * -1, _getEdgeValue(bounding, direction * -1), false);\n                elementEstimate.forcedInBounds = true;\n            }\n        }\n        elementEstimate.elementRectangle = edgeAttempt;\n    }\n    return elementEstimate;\n}\n/**\n * Moves the middle point on an edge to the point given.\n * Only moves in one direction. For instance if a bottom edge is passed in, then\n * the bottom edge will be moved in the x axis to match the point.\n */\nfunction _centerEdgeToPoint(rect, edge, point) {\n    var positiveEdge = _getFlankingEdges(edge).positiveEdge;\n    var elementMiddle = _getCenterValue(rect, edge);\n    var distanceToMiddle = elementMiddle - _getEdgeValue(rect, positiveEdge);\n    return _moveEdge(rect, positiveEdge, point - distanceToMiddle);\n}\n/**\n * Moves the element rectangle to be appropriately positioned relative to a given target.\n * Does not flip or adjust the element.\n */\nfunction _estimatePosition(elementToPosition, target, positionData, gap, coverTarget) {\n    if (gap === void 0) { gap = 0; }\n    var estimatedElementPosition = new Rectangle(elementToPosition.left, elementToPosition.right, elementToPosition.top, elementToPosition.bottom);\n    var alignmentEdge = positionData.alignmentEdge, targetEdge = positionData.targetEdge;\n    var elementEdge = coverTarget ? targetEdge : targetEdge * -1;\n    estimatedElementPosition = coverTarget\n        ? _alignEdges(estimatedElementPosition, target, targetEdge, gap)\n        : _alignOppositeEdges(estimatedElementPosition, target, targetEdge, gap);\n    // if no alignment edge is provided it's supposed to be centered.\n    if (!alignmentEdge) {\n        var targetMiddlePoint = _getCenterValue(target, targetEdge);\n        estimatedElementPosition = _centerEdgeToPoint(estimatedElementPosition, elementEdge, targetMiddlePoint);\n    }\n    else {\n        estimatedElementPosition = _alignEdges(estimatedElementPosition, target, alignmentEdge);\n    }\n    return estimatedElementPosition;\n}\n/**\n * Returns the non-opposite edges of the target edge.\n * For instance if bottom is passed in then left and right will be returned.\n */\nfunction _getFlankingEdges(edge) {\n    if (edge === RectangleEdge.top || edge === RectangleEdge.bottom) {\n        return {\n            positiveEdge: RectangleEdge.left,\n            negativeEdge: RectangleEdge.right,\n        };\n    }\n    else {\n        return {\n            positiveEdge: RectangleEdge.top,\n            negativeEdge: RectangleEdge.bottom,\n        };\n    }\n}\n/**\n * Retrieve the final value for the return edge of `elementRectangle`. If the `elementRectangle` is closer to one side\n * of the bounds versus the other, the return edge is flipped to grow inward.\n */\nfunction _finalizeReturnEdge(elementRectangle, returnEdge, bounds) {\n    if (bounds &&\n        Math.abs(_getRelativeEdgeDifference(elementRectangle, bounds, returnEdge)) >\n            Math.abs(_getRelativeEdgeDifference(elementRectangle, bounds, returnEdge * -1))) {\n        return returnEdge * -1;\n    }\n    return returnEdge;\n}\n/**\n * Whether or not the considered edge of the elementRectangle is lying on the edge of the bounds\n * @param elementRectangle The rectangle whose edge we are considering\n * @param bounds The rectangle marking the bounds\n * @param edge The target edge we're considering\n * @returns If the target edge of the elementRectangle is in the same location as that edge of the bounds\n */\nfunction _isEdgeOnBounds(elementRectangle, edge, bounds) {\n    return bounds !== undefined && _getEdgeValue(elementRectangle, edge) === _getEdgeValue(bounds, edge);\n}\n/**\n * Finalizes the element position based on the hostElement. Only returns the\n * rectangle values to position such that they are anchored to the target.\n * This helps prevent resizing from looking very strange.\n * For instance, if the target edge is top and aligned with the left side then\n * the bottom and left values are returned so as the Callout shrinks it shrinks towards that corner.\n */\nfunction _finalizeElementPosition(elementRectangle, hostElement, targetEdge, bounds, alignmentEdge, coverTarget, doNotFinalizeReturnEdge, forceWithinBounds) {\n    var returnValue = {};\n    var hostRect = _getRectangleFromElement(hostElement);\n    var elementEdge = coverTarget ? targetEdge : targetEdge * -1;\n    var returnEdge = alignmentEdge ? alignmentEdge : _getFlankingEdges(targetEdge).positiveEdge;\n    // If we are finalizing the return edge, choose the edge such that we grow away from the bounds\n    // If we are not finalizing the return edge but the opposite edge is flush against the bounds,\n    // choose that as the anchor edge so the element rect can grow away from the bounds' edge\n    // In this case there will not be a visual difference because there is no more room for the elementRectangle to grow\n    // in the usual direction\n    if (!doNotFinalizeReturnEdge || _isEdgeOnBounds(elementRectangle, getOppositeEdge(returnEdge), bounds)) {\n        returnEdge = _finalizeReturnEdge(elementRectangle, returnEdge, bounds);\n    }\n    returnValue[RectangleEdge[elementEdge]] = _getRelativeEdgeDifference(elementRectangle, hostRect, elementEdge);\n    returnValue[RectangleEdge[returnEdge]] = _getRelativeEdgeDifference(elementRectangle, hostRect, returnEdge);\n    // if the positioned element will still overflow, return all four edges with in-bounds values\n    if (forceWithinBounds) {\n        returnValue[RectangleEdge[elementEdge * -1]] = _getRelativeEdgeDifference(elementRectangle, hostRect, elementEdge * -1);\n        returnValue[RectangleEdge[returnEdge * -1]] = _getRelativeEdgeDifference(elementRectangle, hostRect, returnEdge * -1);\n    }\n    return returnValue;\n}\n// Since the beak is rotated 45 degrees the actual height/width is the length of the diagonal.\n// We still want to position the beak based on it's midpoint which does not change. It will\n// be at (beakwidth / 2, beakwidth / 2)\nfunction _calculateActualBeakWidthInPixels(beakWidth) {\n    return Math.sqrt(beakWidth * beakWidth * 2);\n}\n/**\n * Returns the appropriate IPositionData based on the props altered for RTL.\n * If directionalHintForRTL is passed in that is used if the page is RTL.\n * If directionalHint is specified, no directionalHintForRTL is available, and the page is RTL, the hint will be\n * flipped (e.g. bottomLeftEdge would become bottomRightEdge).\n *\n * If there is no directionalHint passed in, bottomAutoEdge is chosen automatically.\n */\nfunction _getPositionData(directionalHint, directionalHintForRTL, previousPositions) {\n    if (directionalHint === void 0) { directionalHint = DirectionalHint.bottomAutoEdge; }\n    if (previousPositions) {\n        return {\n            alignmentEdge: previousPositions.alignmentEdge,\n            isAuto: previousPositions.isAuto,\n            targetEdge: previousPositions.targetEdge,\n        };\n    }\n    var positionInformation = __assign({}, DirectionalDictionary[directionalHint]);\n    if (getRTL()) {\n        // If alignment edge exists and that alignment edge is -2 or 2, right or left, then flip it.\n        if (positionInformation.alignmentEdge && positionInformation.alignmentEdge % 2 === 0) {\n            positionInformation.alignmentEdge = positionInformation.alignmentEdge * -1;\n        }\n        return directionalHintForRTL !== undefined ? DirectionalDictionary[directionalHintForRTL] : positionInformation;\n    }\n    return positionInformation;\n}\n/**\n * Gets the alignment data for the given information. This only really matters if the positioning is Auto.\n * If it is auto then the alignmentEdge should be chosen based on the target edge's position relative to\n * the center of the page.\n */\nfunction _getAlignmentData(positionData, target, boundingRect, coverTarget, alignTargetEdge) {\n    if (positionData.isAuto) {\n        positionData.alignmentEdge = getClosestEdge(positionData.targetEdge, target, boundingRect);\n    }\n    positionData.alignTargetEdge = alignTargetEdge;\n    return positionData;\n}\nfunction getClosestEdge(targetEdge, target, boundingRect) {\n    var targetCenter = _getCenterValue(target, targetEdge);\n    var boundingCenter = _getCenterValue(boundingRect, targetEdge);\n    var _a = _getFlankingEdges(targetEdge), positiveEdge = _a.positiveEdge, negativeEdge = _a.negativeEdge;\n    if (targetCenter <= boundingCenter) {\n        return positiveEdge;\n    }\n    else {\n        return negativeEdge;\n    }\n}\nfunction _positionElementWithinBounds(elementToPosition, target, bounding, positionData, gap, directionalHintFixed, coverTarget) {\n    var estimatedElementPosition = _estimatePosition(elementToPosition, target, positionData, gap, coverTarget);\n    if (_isRectangleWithinBounds(estimatedElementPosition, bounding)) {\n        return {\n            elementRectangle: estimatedElementPosition,\n            targetEdge: positionData.targetEdge,\n            alignmentEdge: positionData.alignmentEdge,\n        };\n    }\n    else {\n        return _adjustFitWithinBounds(estimatedElementPosition, target, bounding, positionData, gap, directionalHintFixed, coverTarget);\n    }\n}\nfunction _finalizeBeakPosition(elementPosition, positionedBeak, bounds) {\n    var targetEdge = elementPosition.targetEdge * -1;\n    // The \"host\" element that we will use to help position the beak.\n    var actualElement = new Rectangle(0, elementPosition.elementRectangle.width, 0, elementPosition.elementRectangle.height);\n    var returnValue = {};\n    var returnEdge = _finalizeReturnEdge(elementPosition.elementRectangle, elementPosition.alignmentEdge ? elementPosition.alignmentEdge : _getFlankingEdges(targetEdge).positiveEdge, bounds);\n    // only show the beak if the callout is not fully covering the target\n    var beakEdgeDifference = _getRelativeEdgeDifference(elementPosition.elementRectangle, elementPosition.targetRectangle, targetEdge);\n    var showBeak = beakEdgeDifference > Math.abs(_getEdgeValue(positionedBeak, targetEdge));\n    returnValue[RectangleEdge[targetEdge]] = _getEdgeValue(positionedBeak, targetEdge);\n    returnValue[RectangleEdge[returnEdge]] = _getRelativeEdgeDifference(positionedBeak, actualElement, returnEdge);\n    return {\n        elementPosition: __assign({}, returnValue),\n        closestEdge: getClosestEdge(elementPosition.targetEdge, positionedBeak, actualElement),\n        targetEdge: targetEdge,\n        hideBeak: !showBeak,\n    };\n}\nfunction _positionBeak(beakWidth, elementPosition) {\n    var target = elementPosition.targetRectangle;\n    /**\n     * Note about beak positioning: The actual beak width only matters for getting the gap between the callout and\n     * target, it does not impact the beak placement within the callout. For example example, if the beakWidth is 8,\n     * then the actual beakWidth is sqrroot(8^2 + 8^2) = 11.31x11.31. So the callout will need to be an extra 3 pixels\n     * away from its target. While the beak is being positioned in the callout it still acts as though it were 8x8.\n     */\n    var _a = _getFlankingEdges(elementPosition.targetEdge), positiveEdge = _a.positiveEdge, negativeEdge = _a.negativeEdge;\n    var beakTargetPoint = _getCenterValue(target, elementPosition.targetEdge);\n    var elementBounds = new Rectangle(beakWidth / 2, elementPosition.elementRectangle.width - beakWidth / 2, beakWidth / 2, elementPosition.elementRectangle.height - beakWidth / 2);\n    var beakPosition = new Rectangle(0, beakWidth, 0, beakWidth);\n    beakPosition = _moveEdge(beakPosition, elementPosition.targetEdge * -1, -beakWidth / 2);\n    beakPosition = _centerEdgeToPoint(beakPosition, elementPosition.targetEdge * -1, beakTargetPoint - _getRelativeRectEdgeValue(positiveEdge, elementPosition.elementRectangle));\n    if (!_isEdgeInBounds(beakPosition, elementBounds, positiveEdge)) {\n        beakPosition = _alignEdges(beakPosition, elementBounds, positiveEdge);\n    }\n    else if (!_isEdgeInBounds(beakPosition, elementBounds, negativeEdge)) {\n        beakPosition = _alignEdges(beakPosition, elementBounds, negativeEdge);\n    }\n    return beakPosition;\n}\nfunction _getRectangleFromElement(element) {\n    // eslint-disable-next-line deprecation/deprecation\n    var clientRect = element.getBoundingClientRect();\n    return new Rectangle(clientRect.left, clientRect.right, clientRect.top, clientRect.bottom);\n}\nfunction _getRectangleFromIRect(rect) {\n    return new Rectangle(rect.left, rect.right, rect.top, rect.bottom);\n}\nfunction _getTargetRect(bounds, target) {\n    var targetRectangle;\n    if (target) {\n        // eslint-disable-next-line no-extra-boolean-cast\n        if (!!target.preventDefault) {\n            var ev = target;\n            targetRectangle = new Rectangle(ev.clientX, ev.clientX, ev.clientY, ev.clientY);\n            // eslint-disable-next-line no-extra-boolean-cast\n        }\n        else if (!!target.getBoundingClientRect) {\n            targetRectangle = _getRectangleFromElement(target);\n            // HTMLImgElements can have x and y values. The check for it being a point must go last.\n        }\n        else {\n            var rectOrPoint = target;\n            // eslint-disable-next-line deprecation/deprecation\n            var left = rectOrPoint.left || rectOrPoint.x;\n            // eslint-disable-next-line deprecation/deprecation\n            var top_1 = rectOrPoint.top || rectOrPoint.y;\n            var right = rectOrPoint.right || left;\n            var bottom = rectOrPoint.bottom || top_1;\n            targetRectangle = new Rectangle(left, right, top_1, bottom);\n        }\n        if (!_isRectangleWithinBounds(targetRectangle, bounds)) {\n            var outOfBounds = _getOutOfBoundsEdges(targetRectangle, bounds);\n            for (var _i = 0, outOfBounds_1 = outOfBounds; _i < outOfBounds_1.length; _i++) {\n                var direction = outOfBounds_1[_i];\n                targetRectangle[RectangleEdge[direction]] = bounds[RectangleEdge[direction]];\n            }\n        }\n    }\n    else {\n        targetRectangle = new Rectangle(0, 0, 0, 0);\n    }\n    return targetRectangle;\n}\n/**\n * If max height is less than zero it returns the bounds height instead.\n */\nfunction _getMaxHeightFromTargetRectangle(targetRectangle, targetEdge, gapSpace, bounds, coverTarget) {\n    var maxHeight = 0;\n    var directionalHint = DirectionalDictionary[targetEdge];\n    // If cover target is set, then the max height should be calculated using the opposite of the target edge since\n    // that's the direction that the callout will expand in.\n    // For instance, if the directionalhint is bottomLeftEdge then the callout will position so it's bottom edge\n    // is aligned with the bottom of the target and expand up towards the top of the screen and the calculated max height\n    // is (bottom of target) - (top of screen) - gapSpace.\n    var target = coverTarget ? directionalHint.targetEdge * -1 : directionalHint.targetEdge;\n    if (target === RectangleEdge.top) {\n        maxHeight = _getEdgeValue(targetRectangle, directionalHint.targetEdge) - bounds.top - gapSpace;\n    }\n    else if (target === RectangleEdge.bottom) {\n        maxHeight = bounds.bottom - _getEdgeValue(targetRectangle, directionalHint.targetEdge) - gapSpace;\n    }\n    else {\n        maxHeight = bounds.bottom - targetRectangle.top - gapSpace;\n    }\n    return maxHeight > 0 ? maxHeight : bounds.height;\n}\nfunction _positionElementRelative(props, elementToPosition, boundingRect, previousPositions) {\n    var gap = props.gapSpace ? props.gapSpace : 0;\n    var targetRect = _getTargetRect(boundingRect, props.target);\n    var positionData = _getAlignmentData(_getPositionData(props.directionalHint, props.directionalHintForRTL, previousPositions), targetRect, boundingRect, props.coverTarget, props.alignTargetEdge);\n    var positionedElement = _positionElementWithinBounds(_getRectangleFromElement(elementToPosition), targetRect, boundingRect, positionData, gap, props.directionalHintFixed, props.coverTarget);\n    return __assign(__assign({}, positionedElement), { targetRectangle: targetRect });\n}\nfunction _finalizePositionData(positionedElement, hostElement, bounds, coverTarget, doNotFinalizeReturnEdge) {\n    var finalizedElement = _finalizeElementPosition(positionedElement.elementRectangle, hostElement, positionedElement.targetEdge, bounds, positionedElement.alignmentEdge, coverTarget, doNotFinalizeReturnEdge, positionedElement.forcedInBounds);\n    return {\n        elementPosition: finalizedElement,\n        targetEdge: positionedElement.targetEdge,\n        alignmentEdge: positionedElement.alignmentEdge,\n    };\n}\nfunction _positionElement(props, hostElement, elementToPosition, previousPositions) {\n    var boundingRect = props.bounds\n        ? _getRectangleFromIRect(props.bounds)\n        : new Rectangle(0, window.innerWidth - getScrollbarWidth(), 0, window.innerHeight);\n    var positionedElement = _positionElementRelative(props, elementToPosition, boundingRect, previousPositions);\n    return _finalizePositionData(positionedElement, hostElement, boundingRect, props.coverTarget);\n}\nfunction _positionCallout(props, hostElement, callout, previousPositions, doNotFinalizeReturnEdge) {\n    var beakWidth = props.isBeakVisible ? props.beakWidth || 0 : 0;\n    var gap = _calculateActualBeakWidthInPixels(beakWidth) / 2 + (props.gapSpace ? props.gapSpace : 0);\n    var positionProps = props;\n    positionProps.gapSpace = gap;\n    var boundingRect = props.bounds\n        ? _getRectangleFromIRect(props.bounds)\n        : new Rectangle(0, window.innerWidth - getScrollbarWidth(), 0, window.innerHeight);\n    var positionedElement = _positionElementRelative(positionProps, callout, boundingRect, previousPositions);\n    var beakPositioned = _positionBeak(beakWidth, positionedElement);\n    var finalizedBeakPosition = _finalizeBeakPosition(positionedElement, beakPositioned, boundingRect);\n    return __assign(__assign({}, _finalizePositionData(positionedElement, hostElement, boundingRect, props.coverTarget, doNotFinalizeReturnEdge)), { beakPosition: finalizedBeakPosition });\n}\nfunction _positionCard(props, hostElement, callout, previousPositions) {\n    return _positionCallout(props, hostElement, callout, previousPositions, true);\n}\n// END PRIVATE FUNCTIONS\nexport var __positioningTestPackage = {\n    _finalizePositionData: _finalizePositionData,\n    _finalizeBeakPosition: _finalizeBeakPosition,\n    _calculateActualBeakWidthInPixels: _calculateActualBeakWidthInPixels,\n    _positionElementWithinBounds: _positionElementWithinBounds,\n    _positionBeak: _positionBeak,\n    _getPositionData: _getPositionData,\n    _getMaxHeightFromTargetRectangle: _getMaxHeightFromTargetRectangle,\n};\n/**\n * Used to position an element relative to the given positioning props.\n * If positioning has been completed before, previousPositions can be passed to ensure that the positioning element\n * repositions based on its previous targets rather than starting with directionalhint.\n */\nexport function positionElement(props, hostElement, elementToPosition, previousPositions) {\n    return _positionElement(props, hostElement, elementToPosition, previousPositions);\n}\nexport function positionCallout(props, hostElement, elementToPosition, previousPositions) {\n    return _positionCallout(props, hostElement, elementToPosition, previousPositions);\n}\nexport function positionCard(props, hostElement, elementToPosition, previousPositions) {\n    return _positionCard(props, hostElement, elementToPosition, previousPositions);\n}\n/**\n * Gets the maximum height that a rectangle can have in order to fit below or above a target.\n * If the directional hint specifies a left or right edge (i.e. leftCenter) it will limit the height to the topBorder\n * of the target given.\n * If no bounds are provided then the window is treated as the bounds.\n */\nexport function getMaxHeight(target, targetEdge, gapSpace, bounds, coverTarget) {\n    if (gapSpace === void 0) { gapSpace = 0; }\n    var mouseTarget = target;\n    var elementTarget = target;\n    var rectOrPointTarget = target;\n    var targetRect;\n    var boundingRectangle = bounds\n        ? _getRectangleFromIRect(bounds)\n        : new Rectangle(0, window.innerWidth - getScrollbarWidth(), 0, window.innerHeight);\n    // eslint-disable-next-line deprecation/deprecation\n    var left = rectOrPointTarget.left || rectOrPointTarget.x;\n    // eslint-disable-next-line deprecation/deprecation\n    var top = rectOrPointTarget.top || rectOrPointTarget.y;\n    var right = rectOrPointTarget.right || left;\n    var bottom = rectOrPointTarget.bottom || top;\n    // eslint-disable-next-line no-extra-boolean-cast -- may not actually be a MouseEvent\n    if (!!mouseTarget.stopPropagation) {\n        targetRect = new Rectangle(mouseTarget.clientX, mouseTarget.clientX, mouseTarget.clientY, mouseTarget.clientY);\n    }\n    else if (left !== undefined && top !== undefined) {\n        targetRect = new Rectangle(left, right, top, bottom);\n    }\n    else {\n        targetRect = _getRectangleFromElement(elementTarget);\n    }\n    return _getMaxHeightFromTargetRectangle(targetRect, targetEdge, gapSpace, boundingRectangle, coverTarget);\n}\n/**\n * Returns the opposite edge of the given RectangleEdge.\n */\nexport function getOppositeEdge(edge) {\n    return edge * -1;\n}\nfunction _getBoundsFromTargetWindow(target, targetWindow) {\n    var segments = undefined;\n    if (targetWindow.getWindowSegments) {\n        segments = targetWindow.getWindowSegments();\n    }\n    // Identify if we're dealing with single screen scenarios.\n    if (segments === undefined || segments.length <= 1) {\n        return {\n            top: 0,\n            left: 0,\n            right: targetWindow.innerWidth,\n            bottom: targetWindow.innerHeight,\n            width: targetWindow.innerWidth,\n            height: targetWindow.innerHeight,\n        };\n    }\n    // Logic for determining dual screen scenarios.\n    var x = 0;\n    var y = 0;\n    // If the target is an Element get coordinates for its center.\n    if (target !== null && !!target.getBoundingClientRect) {\n        var clientRect = target.getBoundingClientRect();\n        x = (clientRect.left + clientRect.right) / 2;\n        y = (clientRect.top + clientRect.bottom) / 2;\n    }\n    // If the target is not null get x-axis and y-axis coordinates directly.\n    else if (target !== null) {\n        // eslint-disable-next-line deprecation/deprecation\n        x = target.left || target.x;\n        // eslint-disable-next-line deprecation/deprecation\n        y = target.top || target.y;\n    }\n    var bounds = { top: 0, left: 0, right: 0, bottom: 0, width: 0, height: 0 };\n    // Define which window segment are the coordinates in and calculate bounds based on that.\n    for (var _i = 0, segments_1 = segments; _i < segments_1.length; _i++) {\n        var segment = segments_1[_i];\n        if (x && segment.left <= x && segment.right >= x && y && segment.top <= y && segment.bottom >= y) {\n            bounds = {\n                top: segment.top,\n                left: segment.left,\n                right: segment.right,\n                bottom: segment.bottom,\n                width: segment.width,\n                height: segment.height,\n            };\n        }\n    }\n    return bounds;\n}\nexport function getBoundsFromTargetWindow(target, targetWindow) {\n    return _getBoundsFromTargetWindow(target, targetWindow);\n}\n//# sourceMappingURL=positioning.js.map","export var RectangleEdge;\n(function (RectangleEdge) {\n    RectangleEdge[RectangleEdge[\"top\"] = 1] = \"top\";\n    RectangleEdge[RectangleEdge[\"bottom\"] = -1] = \"bottom\";\n    RectangleEdge[RectangleEdge[\"left\"] = 2] = \"left\";\n    RectangleEdge[RectangleEdge[\"right\"] = -2] = \"right\";\n})(RectangleEdge || (RectangleEdge = {}));\nexport var Position;\n(function (Position) {\n    Position[Position[\"top\"] = 0] = \"top\";\n    Position[Position[\"bottom\"] = 1] = \"bottom\";\n    Position[Position[\"start\"] = 2] = \"start\";\n    Position[Position[\"end\"] = 3] = \"end\";\n})(Position || (Position = {}));\n//# sourceMappingURL=positioning.types.js.map","export function getAllSelectedOptions(options, selectedIndices) {\n    var selectedOptions = [];\n    for (var _i = 0, selectedIndices_1 = selectedIndices; _i < selectedIndices_1.length; _i++) {\n        var index = selectedIndices_1[_i];\n        var option = options[index];\n        if (option) {\n            selectedOptions.push(option);\n        }\n    }\n    return selectedOptions;\n}\n//# sourceMappingURL=SelectableOption.js.map","export var SelectableOptionMenuItemType;\n(function (SelectableOptionMenuItemType) {\n    SelectableOptionMenuItemType[SelectableOptionMenuItemType[\"Normal\"] = 0] = \"Normal\";\n    SelectableOptionMenuItemType[SelectableOptionMenuItemType[\"Divider\"] = 1] = \"Divider\";\n    SelectableOptionMenuItemType[SelectableOptionMenuItemType[\"Header\"] = 2] = \"Header\";\n    SelectableOptionMenuItemType[SelectableOptionMenuItemType[\"SelectAll\"] = 3] = \"SelectAll\";\n})(SelectableOptionMenuItemType || (SelectableOptionMenuItemType = {}));\n//# sourceMappingURL=SelectableOption.types.js.map","// A packages cache that makes sure that we don't inject the same packageName twice in the same bundle -\n// this cache is local to the module closure inside this bundle\nvar packagesCache = {};\n// Cache access to window to avoid IE11 memory leak.\nvar _win = undefined;\ntry {\n    _win = window;\n}\ncatch (e) {\n    /* no-op */\n}\nexport function setVersion(packageName, packageVersion) {\n    if (typeof _win !== 'undefined') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var packages = (_win.__packages__ = _win.__packages__ || {});\n        // We allow either the global packages or local packages caches to invalidate so testing can\n        // just clear the global to set this state\n        if (!packages[packageName] || !packagesCache[packageName]) {\n            packagesCache[packageName] = packageVersion;\n            var versions = (packages[packageName] = packages[packageName] || []);\n            versions.push(packageVersion);\n        }\n    }\n}\n//# sourceMappingURL=setVersion.js.map","import { setVersion } from './setVersion';\nexport { setVersion };\nsetVersion('@fluentui/set-version', '6.0.0');\n//# sourceMappingURL=index.js.map"],"names":["getClassNames","memoize","className","isDragging","root","touchAction","selectors","userSelect","eventMapping","start","move","stop","DraggableZone","_super","props","_this","call","this","_currentEventType","_events","_onMouseDown","event","onMouseDown","children","_onDragStart","_onMouseUp","onMouseUp","_onDragStop","_onTouchStart","onTouchStart","_onTouchEnd","onTouchEnd","button","handleSelector","_matchesSelector","target","preventDragSelector","_touchId","_getTouchId","position","_getControlPosition","undefined","dragData","_createDragDataFromPosition","onStart","setState","lastPosition","on","document","body","_onDrag","type","preventDefault","updatedData","_createUpdatedDragData","updatedPosition","onDragChange","state","baseDragData","onStop","forEach","dispose","x","y","prototype","componentDidUpdate","prevProps","componentWillUnmount","render","child","_a","statePosition","style","transform","concat","touchObj","_getActiveTouch","eventToGetOffset","clientX","clientY","targetTouches","_findTouchInTouchList","changedTouches","touch","identifier","element","selector","matchesSelectorFn","matches","webkitMatchesSelector","msMatchesSelector","parentElement","touchList","i","length","delta","MenuContext","ThemeContext","_seed","mergeStylesRenderer","reset","Stylesheet","onReset","getId","renderStyles","styleSet","options","Array","isArray","renderFontFace","fontFace","renderKeyframes","keyframes","styleOrFunction","graph","allWindows","cleanupMapEntries","useThemeProviderStyles","theme","semanticColors","fonts","color","bodyText","background","bodyBackground","fontFamily","medium","fontWeight","fontSize","MozOsxFontSmoothing","WebkitFontSmoothing","Map","Set","ev","win","currentTarget","winId","__id__","delete","removeEventListener","has","add","addEventListener","contextualTheme","useTheme","id","path","value","graphNode","_b","_c","_d","windowId","get","classMap","graphGet","useEffect","node","refCount","graphRef","_e","_f","_g","_h","_j","size","graphDeref","styles","isStyleFunction","targetWindow","rtl","windowNode","set","idNode","graphSet","useThemeProviderClasses","classes","applyTo","classesToApply","applyToBody","_i","classesToApply_1","classToApply","classList","classesToApply_2","remove","useApplyClassToBody","css","renderThemeProvider","customizerContext","ref","Root","as","rootProps","getNativeElementProps","CustomizerContext","FocusRectsProvider","providerRef","themeToIdMap","useThemeProviderState","draftState","userTheme","parentTheme","mergedTheme","mergeThemes","themes","arguments","ids","themes_1","push","join","getThemeId","customizations","inCustomizerContext","settings","scopedSettings","components","dir","ThemeProvider","defaultProps","getPropsWithDefaults","useThemeProvider","useMergedRefs","displayName","useContext","legacyTheme","getIsChecked","item","canCheck","isChecked","checked","hasSubmenu","subMenuProps","items","isItemDisabled","isDisabled","disabled","getMenuItemAriaRole","ResponsiveMode","_defaultMode","_lastMode","RESPONSIVE_MAX_CONSTRAINT","getInitialResponsiveMode","large","getWidthOfCurrentWindow","currentWindow","documentElement","clientWidth","e","innerWidth","getResponsiveMode","responsiveMode","small","Error","useResponsiveMode","elementRef","overrideResponsiveMode","lastResponsiveMode","setLastResponsiveMode","onResize","newResponsiveMode","current","KeytipEvents","KTP_PREFIX","KTP_SEPARATOR","DATAKTP_TARGET","DATAKTP_EXECUTE_TARGET","KTP_LAYER_ID","KEYTIP_ADDED","KEYTIP_REMOVED","KEYTIP_UPDATED","PERSISTED_KEYTIP_ADDED","PERSISTED_KEYTIP_REMOVED","PERSISTED_KEYTIP_EXECUTE","ENTER_KEYTIP_MODE","EXIT_KEYTIP_MODE","KeytipManager","keytips","persistedKeytips","sequenceMapping","inKeytipMode","shouldEnterKeytipMode","delayUpdatingKeytipChange","getInstance","_instance","init","register","keytipProps","persisted","addParentOverflow","keySequences","toString","uniqueKeytip","_getUniqueKtp","uniqueID","event_1","keytip","update","newKeytipProps","oldKeyTip","visible","unregister","keytipToRemove","enterKeytipMode","exitKeytipMode","getKeytips","Object","keys","map","key","fullSequence","pop","parentKeytip","overflowSetSequence","menuExecute","overflowButtonSequences","keytipSequences","sequencesToID","reduce","prevValue","keySequence","split","mergeOverflows","overflowKeySequences","overflowSequenceLen","overflowSequence","newKeySequences","getAriaDescribedBy","describedby","_createPositionData","targetEdge","alignmentEdge","isAuto","DirectionalDictionary","_isRectangleWithinBounds","rect","boundingRect","top","bottom","left","right","_getOutOfBoundsEdges","outOfBounds","_getEdgeValue","edge","_setEdgeValue","_getCenterValue","edges","_getFlankingEdges","positiveEdge","negativeEdge","_getRelativeEdgeValue","_getRelativeRectEdgeValue","_getRelativeEdgeDifference","hostRect","_moveEdge","newValue","maintainSize","difference","returnRect","_alignEdges","gap","_isEdgeInBounds","bounds","_getOutOfBoundsDegree","total","breakingEdges_1","Math","pow","_adjustFitWithinBounds","bounding","positionData","directionalHintFixed","coverTarget","alignTargetEdge","elementEstimate","elementRectangle","directions","oobDegree","currentEstimate","currentEdge","currentAlignment","bestEdge","bestAlignment","currentOOBDegree","splice","indexOf","slice","_estimatePosition","_flipToFit","fixedEdge","flippedElementEstimate","oppositeEdge","_flipAlignmentEdge","_alignOutOfBoundsEdges","outOfBoundsEdges","preserveEdge","outOfBoundsEdges_1","direction","edgeAttempt","forcedInBounds","_centerEdgeToPoint","point","elementToPosition","estimatedElementPosition","elementEdge","adjustedGap","_alignOppositeEdges","_finalizeReturnEdge","returnEdge","abs","_finalizeElementPosition","hostElement","doNotFinalizeReturnEdge","forceWithinBounds","returnValue","_getRectangleFromElement","_isEdgeOnBounds","_calculateActualBeakWidthInPixels","beakWidth","sqrt","_getPositionData","directionalHint","directionalHintForRTL","previousPositions","positionInformation","getClosestEdge","targetCenter","boundingCenter","_positionElementWithinBounds","_finalizeBeakPosition","elementPosition","positionedBeak","actualElement","width","height","showBeak","targetRectangle","closestEdge","hideBeak","_positionBeak","beakTargetPoint","elementBounds","beakPosition","clientRect","getBoundingClientRect","_getRectangleFromIRect","_positionElementRelative","gapSpace","targetRect","rectOrPoint","top_1","outOfBounds_1","_getTargetRect","_getAlignmentData","positionedElement","_finalizePositionData","_positionCallout","callout","isBeakVisible","positionProps","window","innerHeight","finalizedBeakPosition","positionCallout","positionCard","_positionCard","getBoundsFromTargetWindow","segments","getWindowSegments","segments_1","segment","_getBoundsFromTargetWindow","RectangleEdge","Position","getAllSelectedOptions","selectedIndices","selectedOptions","selectedIndices_1","option","SelectableOptionMenuItemType","packagesCache","_win","setVersion","packageName","packageVersion","packages","__packages__"],"sourceRoot":""}