{"version":3,"file":"static/js/3351_6dfcb9774ca16c11bb10.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/dom.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/hooks/useResponsiveMode.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/keytips/KeytipConstants.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/keytips/KeytipManager.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/keytips/KeytipUtils.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/positioning/positioning.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_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.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/selectableOption/SelectableOption.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/selectableOption/SelectableOption.types.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/useOverflow.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+react@8.122.5_53swvjg5d4vee6odcktdjzlijq/node_modules/@fluentui/react/lib/utilities/observeResize.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+set-version@8.2.23/node_modules/@fluentui/set-version/lib/setVersion.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@fluentui+set-version@8.2.23/node_modules/@fluentui/set-version/lib/index.js"],"sourcesContent":["import { useDocument, useWindow } from '@fluentui/react-window-provider';\n/**\n * NOTE: the check for `window`/`document` is a bit verbose and perhaps\n * overkill but it ensures the prior assumbed behavior of directly\n * calling `window`/`document` is preserved.\n *\n * It is possible to set `window` to undefined on `WindowProvider` so\n * we'll fallback to directly accessing the global in that (hopefully unlikely)\n * case.\n */\n/**\n * Get a reference to the `document` object.\n * Use this in place of the global `document` in React function components.\n * @returns Document | undefined\n */\nexport var useDocumentEx = function () {\n    var _a;\n    // eslint-disable-next-line no-restricted-globals\n    return (_a = useDocument()) !== null && _a !== void 0 ? _a : (typeof document !== 'undefined' ? document : undefined);\n};\n/**\n * Get a reference to the `window` object.\n * Use this in place of the global `window` in React function components.\n * @returns Window | undefined\n */\nexport var useWindowEx = function () {\n    var _a;\n    // eslint-disable-next-line no-restricted-globals\n    return (_a = useWindow()) !== null && _a !== void 0 ? _a : (typeof window !== 'undefined' ? window : undefined);\n};\n/**\n * Get a reference to the `document` object.\n * Use this in place of the global `document` in React class components.\n *\n * @param ctx - Class component WindowContext\n * @returns Document | undefined\n */\nexport var getDocumentEx = function (ctx) {\n    var _a, _b;\n    // eslint-disable-next-line no-restricted-globals\n    return (_b = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.window) === null || _a === void 0 ? void 0 : _a.document) !== null && _b !== void 0 ? _b : (typeof document !== 'undefined' ? document : undefined);\n};\n/**\n * Get a reference to the `window` object.\n * Use this in place of the global `window` in React class components.\n *\n * @param ctx - Class component WindowContext\n * @returns Window | undefined\n */\nexport var getWindowEx = function (ctx) {\n    var _a;\n    // eslint-disable-next-line no-restricted-globals\n    return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.window) !== null && _a !== void 0 ? _a : (typeof window !== 'undefined' ? window : undefined);\n};\n//# sourceMappingURL=dom.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, getWindow } 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 * Returns true if scroll-resizing will move the target edge within the bounding rectangle,\n * and there is room between the target edge and the bounding edge for scrolled content.\n * Returns false otherwise.\n */\nfunction _canScrollResizeToFitEdge(target, bounding, targetEdge, minimumScrollResizeHeight) {\n    if (minimumScrollResizeHeight === void 0) { minimumScrollResizeHeight = 200; }\n    // Only scroll vertically to fit - cannot scroll to fit right or left edges\n    if (targetEdge !== RectangleEdge.bottom && targetEdge !== RectangleEdge.top) {\n        return false;\n    }\n    return _getRelativeEdgeDifference(target, bounding, targetEdge) >= minimumScrollResizeHeight;\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, shouldScroll, minimumScrollResizeHeight, gap) {\n    if (shouldScroll === void 0) { shouldScroll = false; }\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            // Edge is in bounds, return current estimate\n            return {\n                elementRectangle: currentEstimate,\n                targetEdge: currentEdge,\n                alignmentEdge: currentAlignment,\n            };\n        }\n        else if (shouldScroll && _canScrollResizeToFitEdge(target, bounding, currentEdge, minimumScrollResizeHeight)) {\n            // Scrolling will allow edge to fit, move the estimate currentEdge inside the bounds and return\n            switch (currentEdge) {\n                case RectangleEdge.bottom:\n                    currentEstimate.bottom = bounding.bottom;\n                    break;\n                case RectangleEdge.top:\n                    currentEstimate.top = bounding.top;\n                    break;\n            }\n            return {\n                elementRectangle: currentEstimate,\n                targetEdge: currentEdge,\n                alignmentEdge: currentAlignment,\n                forcedInBounds: true,\n            };\n        }\n        else {\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    }\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, shouldScroll, minimumScrollResizeHeight, gap, directionalHintFixed, coverTarget) {\n    if (shouldScroll === void 0) { shouldScroll = false; }\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, shouldScroll, minimumScrollResizeHeight, 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, shouldScroll, minimumScrollResizeHeight, directionalHintFixed, coverTarget) {\n    if (shouldScroll === void 0) { shouldScroll = false; }\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, shouldScroll, minimumScrollResizeHeight, 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, shouldScroll, minimumScrollResizeHeight) {\n    if (shouldScroll === void 0) { shouldScroll = false; }\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, shouldScroll, minimumScrollResizeHeight, 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, win) {\n    var theWin = win !== null && win !== void 0 ? win : getWindow();\n    var boundingRect = props.bounds\n        ? _getRectangleFromIRect(props.bounds)\n        : new Rectangle(0, theWin.innerWidth - getScrollbarWidth(), 0, theWin.innerHeight);\n    var positionedElement = _positionElementRelative(props, elementToPosition, boundingRect, previousPositions);\n    return _finalizePositionData(positionedElement, hostElement, boundingRect, props.coverTarget);\n}\nfunction _calculateGapSpace(isBeakVisible, beakWidth, gapSpace) {\n    if (beakWidth === void 0) { beakWidth = 0; }\n    if (gapSpace === void 0) { gapSpace = 0; }\n    return _calculateActualBeakWidthInPixels(isBeakVisible ? beakWidth : 0) / 2 + gapSpace;\n}\nfunction _positionCallout(props, hostElement, callout, previousPositions, shouldScroll, minimumScrollResizeHeight, doNotFinalizeReturnEdge, win) {\n    if (shouldScroll === void 0) { shouldScroll = false; }\n    var theWin = win !== null && win !== void 0 ? win : getWindow();\n    var beakWidth = props.isBeakVisible ? props.beakWidth || 0 : 0;\n    var gap = _calculateGapSpace(props.isBeakVisible, props.beakWidth, props.gapSpace);\n    var positionProps = props;\n    positionProps.gapSpace = gap;\n    var boundingRect = props.bounds\n        ? _getRectangleFromIRect(props.bounds)\n        : new Rectangle(0, theWin.innerWidth - getScrollbarWidth(), 0, theWin.innerHeight);\n    var positionedElement = _positionElementRelative(positionProps, callout, boundingRect, previousPositions, shouldScroll, minimumScrollResizeHeight);\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, win) {\n    var theWin = win !== null && win !== void 0 ? win : getWindow();\n    return _positionCallout(props, hostElement, callout, previousPositions, false, undefined, true, theWin);\n}\nfunction _getRectangleFromTarget(target) {\n    var _a, _b, _c, _d;\n    var mouseTarget = target;\n    var elementTarget = target;\n    var rectOrPointTarget = target;\n    var targetRect;\n    // eslint-disable-next-line deprecation/deprecation\n    var left = (_a = rectOrPointTarget.left) !== null && _a !== void 0 ? _a : rectOrPointTarget.x;\n    // eslint-disable-next-line deprecation/deprecation\n    var top = (_b = rectOrPointTarget.top) !== null && _b !== void 0 ? _b : rectOrPointTarget.y;\n    var right = (_c = rectOrPointTarget.right) !== null && _c !== void 0 ? _c : left;\n    var bottom = (_d = rectOrPointTarget.bottom) !== null && _d !== void 0 ? _d : 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 targetRect;\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, win) {\n    return _positionElement(props, hostElement, elementToPosition, previousPositions, win);\n}\nexport function positionCallout(props, hostElement, elementToPosition, previousPositions, shouldScroll, minimumScrollResizeHeight, win) {\n    return _positionCallout(props, hostElement, elementToPosition, previousPositions, shouldScroll, minimumScrollResizeHeight, undefined, win);\n}\nexport function positionCard(props, hostElement, elementToPosition, previousPositions, win) {\n    return _positionCard(props, hostElement, elementToPosition, previousPositions, win);\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, win) {\n    if (gapSpace === void 0) { gapSpace = 0; }\n    var theWin = win !== null && win !== void 0 ? win : getWindow();\n    var targetRect = _getRectangleFromTarget(target);\n    var boundingRectangle = bounds\n        ? _getRectangleFromIRect(bounds)\n        : new Rectangle(0, theWin.innerWidth - getScrollbarWidth(), 0, theWin.innerHeight);\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}\nexport function calculateGapSpace(isBeakVisible, beakWidth, gapSpace) {\n    return _calculateGapSpace(isBeakVisible, beakWidth, gapSpace);\n}\nexport function getRectangleFromTarget(target) {\n    return _getRectangleFromTarget(target);\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","import * as React from 'react';\nimport { useIsomorphicLayoutEffect, useRefEffect } from '@fluentui/react-hooks';\nimport { getWindow } from '@fluentui/utilities';\nimport { observeResize } from './observeResize';\n/**\n * Track whether any items don't fit within their container, and move them to the overflow menu.\n * Items are moved into the overflow menu from back to front, excluding pinned items.\n *\n * The overflow menu button must be the last sibling of all of the items that can be put into the overflow, and it\n * must be hooked up to the `setMenuButtonRef` setter function that's returned by `useOverflow`:\n * ```ts\n * const overflow = useOverflow(...);\n * ```\n * ```jsx\n * <Container>\n *  <Item /> // Index 0\n *  <Item /> // Index 1\n *  ...\n *  <Button ref={overflow.setMenuButtonRef} /> // Can be any React.Component or HTMLElement\n * </Container>\n * ```\n */\nexport var useOverflow = function (_a) {\n    var onOverflowItemsChanged = _a.onOverflowItemsChanged, rtl = _a.rtl, pinnedIndex = _a.pinnedIndex;\n    var updateOverflowRef = React.useRef();\n    var containerWidthRef = React.useRef();\n    // Attach a resize observer to the container\n    var containerRef = useRefEffect(function (container) {\n        var cleanupObserver = observeResize(container, function (entries) {\n            containerWidthRef.current = entries ? entries[0].contentRect.width : container.clientWidth;\n            if (updateOverflowRef.current) {\n                updateOverflowRef.current();\n            }\n        });\n        return function () {\n            cleanupObserver();\n            containerWidthRef.current = undefined;\n        };\n    });\n    var menuButtonRef = useRefEffect(function (menuButton) {\n        containerRef(menuButton.parentElement);\n        return function () { return containerRef(null); };\n    });\n    useIsomorphicLayoutEffect(function () {\n        var container = containerRef.current;\n        var menuButton = menuButtonRef.current;\n        if (!container || !menuButton) {\n            return;\n        }\n        // items contains the container's children, excluding the overflow menu button itself\n        var items = [];\n        for (var i = 0; i < container.children.length; i++) {\n            var item = container.children[i];\n            if (item instanceof HTMLElement && item !== menuButton) {\n                items.push(item);\n            }\n        }\n        // Keep track of the minimum width of the container to fit each child index.\n        // This cache is an integral part of the algorithm and not just a performance optimization: it allows us to\n        // recalculate the overflowIndex on subsequent resizes even if some items are already inside the overflow.\n        var minContainerWidth = [];\n        var extraWidth = 0; // The accumulated width of items that don't move into the overflow\n        updateOverflowRef.current = function () {\n            var containerWidth = containerWidthRef.current;\n            if (containerWidth === undefined) {\n                return;\n            }\n            // Iterate the items in reverse order until we find one that fits within the bounds of the container\n            for (var i = items.length - 1; i >= 0; i--) {\n                // Calculate the min container width for this item if we haven't done so yet\n                if (minContainerWidth[i] === undefined) {\n                    var itemOffsetEnd = rtl ? containerWidth - items[i].offsetLeft : items[i].offsetLeft + items[i].offsetWidth;\n                    // If the item after this one is pinned, reserve space for it\n                    if (i + 1 < items.length && i + 1 === pinnedIndex) {\n                        // Use distance between the end of the previous item and this one (rather than the\n                        // pinned item's offsetWidth), to account for any margin between the items.\n                        extraWidth = minContainerWidth[i + 1] - itemOffsetEnd;\n                    }\n                    // Reserve space for the menu button after the first item was added to the overflow\n                    if (i === items.length - 2) {\n                        extraWidth += menuButton.offsetWidth;\n                    }\n                    minContainerWidth[i] = itemOffsetEnd + extraWidth;\n                }\n                if (containerWidth > minContainerWidth[i]) {\n                    setOverflowIndex(i + 1);\n                    return;\n                }\n            }\n            // If we got here, nothing fits outside the overflow\n            setOverflowIndex(0);\n        };\n        var prevOverflowIndex = items.length;\n        var setOverflowIndex = function (overflowIndex) {\n            if (prevOverflowIndex !== overflowIndex) {\n                prevOverflowIndex = overflowIndex;\n                onOverflowItemsChanged(overflowIndex, items.map(function (ele, index) { return ({\n                    ele: ele,\n                    isOverflowing: index >= overflowIndex && index !== pinnedIndex,\n                }); }));\n            }\n        };\n        var cancelAnimationFrame = undefined;\n        // If the container width is already known from a previous render, update the overflow with its width.\n        // Do this in an animation frame to avoid forcing layout to happen early.\n        if (containerWidthRef.current !== undefined) {\n            var win_1 = getWindow(container);\n            if (win_1) {\n                var animationFrameId_1 = win_1.requestAnimationFrame(updateOverflowRef.current);\n                cancelAnimationFrame = function () { return win_1.cancelAnimationFrame(animationFrameId_1); };\n            }\n        }\n        return function () {\n            if (cancelAnimationFrame) {\n                cancelAnimationFrame();\n            }\n            // On cleanup, need to remove all items from the overflow\n            // so they don't have stale properties on the next render\n            setOverflowIndex(items.length);\n            updateOverflowRef.current = undefined;\n        };\n    });\n    return { menuButtonRef: menuButtonRef };\n};\n//# sourceMappingURL=useOverflow.js.map","import { getWindow } from '@fluentui/utilities';\n/**\n * Wrapper for ResizeObserver, with fallback for browsers that don't support ResizeObserver.\n *\n * Calls the onResize callback once layout is complete, and again whenever any of the target(s) change size.\n * Or if ResizeObserver isn't supported, calls the callback whenever the window changes size.\n *\n * @param target - Either a single element, or array of elements to watch for size changes.\n * @param onResize - Callback to be notified when layout is complete, and when the target(s) change size.\n *    If this browser supports ResizeObserver, the callback will be passed the ResizeObserverEntry[] array.\n *    Otherwise, the entries array will be undefined, and you'll need to find another way to get the element's size,\n *    (e.g. clientWidth/clientHeight or getBoundingClientRect).\n *\n * @returns A function to clean up the observer/listener.\n */\nexport var observeResize = function (target, onResize) {\n    if (typeof ResizeObserver !== 'undefined') {\n        var observer_1 = new ResizeObserver(onResize);\n        if (Array.isArray(target)) {\n            target.forEach(function (t) { return observer_1.observe(t); });\n        }\n        else {\n            observer_1.observe(target);\n        }\n        return function () { return observer_1.disconnect(); };\n    }\n    else {\n        // Fallback for browsers that don't support ResizeObserver\n        var onResizeWrapper_1 = function () { return onResize(undefined); };\n        var win_1 = getWindow(Array.isArray(target) ? target[0] : target);\n        if (!win_1) {\n            // Can't listen for resize if we can't get the window object\n            return function () {\n                // Nothing to clean up\n            };\n        }\n        // Listen for the first animation frame, which will happen after layout is complete\n        var animationFrameId_1 = win_1.requestAnimationFrame(onResizeWrapper_1);\n        win_1.addEventListener('resize', onResizeWrapper_1, false);\n        return function () {\n            win_1.cancelAnimationFrame(animationFrameId_1);\n            win_1.removeEventListener('resize', onResizeWrapper_1, false);\n        };\n    }\n};\n//# sourceMappingURL=observeResize.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":["useWindowEx","_a","window","undefined","getDocumentEx","ctx","_b","document","getWindowEx","useResponsiveMode","elementRef","overrideResponsiveMode","lastResponsiveMode","setLastResponsiveMode","onResize","newResponsiveMode","current","win","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","this","keytips","persistedKeytips","sequenceMapping","inKeytipMode","shouldEnterKeytipMode","delayUpdatingKeytipChange","getInstance","_instance","prototype","init","register","keytipProps","persisted","props","addParentOverflow","keySequences","toString","uniqueKeytip","_getUniqueKtp","uniqueID","event_1","keytip","update","newKeytipProps","oldKeyTip","visible","unregister","keytipToRemove","event","enterKeytipMode","exitKeytipMode","getKeytips","_this","Object","keys","map","key","fullSequence","pop","length","parentKeytip","overflowSetSequence","menuExecute","overflowButtonSequences","keytipSequences","sequencesToID","reduce","prevValue","keySequence","split","join","mergeOverflows","overflowKeySequences","overflowSequenceLen","overflowSequence","newKeySequences","getAriaDescribedBy","describedby","_createPositionData","targetEdge","alignmentEdge","isAuto","DirectionalDictionary","_isRectangleWithinBounds","rect","boundingRect","top","bottom","left","right","_getOutOfBoundsEdges","outOfBounds","push","_getEdgeValue","edge","_setEdgeValue","value","_getCenterValue","edges","_getFlankingEdges","positiveEdge","negativeEdge","_getRelativeEdgeValue","_getRelativeRectEdgeValue","_getRelativeEdgeDifference","hostRect","_moveEdge","newValue","maintainSize","difference","returnRect","_alignEdges","target","gap","_isEdgeInBounds","bounds","_getOutOfBoundsDegree","total","_i","breakingEdges_1","Math","pow","_canScrollResizeToFitEdge","bounding","minimumScrollResizeHeight","_adjustFitWithinBounds","element","positionData","shouldScroll","directionalHintFixed","coverTarget","alignTargetEdge","elementEstimate","elementRectangle","directions","oobDegree","currentEstimate","currentEdge","currentAlignment","bestEdge","bestAlignment","i","forcedInBounds","currentOOBDegree","splice","indexOf","slice","_estimatePosition","_flipToFit","fixedEdge","flippedElementEstimate","oppositeEdge","_flipAlignmentEdge","_alignOutOfBoundsEdges","outOfBoundsEdges","preserveEdge","outOfBoundsEdges_1","direction","edgeAttempt","_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","preventDefault","ev","clientX","clientY","rectOrPoint","x","top_1","y","outOfBounds_1","_getTargetRect","_getAlignmentData","positionedElement","_finalizePositionData","_calculateGapSpace","isBeakVisible","_positionCallout","callout","theWin","positionProps","innerWidth","innerHeight","finalizedBeakPosition","_getRectangleFromTarget","_c","_d","mouseTarget","elementTarget","rectOrPointTarget","stopPropagation","positionCallout","positionCard","_positionCard","getBoundsFromTargetWindow","targetWindow","segments","getWindowSegments","segments_1","segment","_getBoundsFromTargetWindow","calculateGapSpace","getRectangleFromTarget","RectangleEdge","Position","getAllSelectedOptions","options","selectedIndices","selectedOptions","selectedIndices_1","option","SelectableOptionMenuItemType","useOverflow","onOverflowItemsChanged","rtl","pinnedIndex","updateOverflowRef","containerWidthRef","containerRef","useRefEffect","container","cleanupObserver","ResizeObserver","observer_1","Array","isArray","forEach","t","observe","disconnect","onResizeWrapper_1","win_1","getWindow","animationFrameId_1","requestAnimationFrame","addEventListener","cancelAnimationFrame","removeEventListener","observeResize","entries","contentRect","clientWidth","menuButtonRef","menuButton","parentElement","useIsomorphicLayoutEffect","items","children","item","HTMLElement","minContainerWidth","extraWidth","containerWidth","itemOffsetEnd","offsetLeft","offsetWidth","setOverflowIndex","prevOverflowIndex","overflowIndex","ele","index","isOverflowing","packagesCache","_win","e","setVersion","packageName","packageVersion","packages","__packages__"],"sourceRoot":""}