{"version":3,"file":"static/js/vendor.fluentui.react~57579a93.fb668107.js","mappings":"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H,EAAY,CACvC,SACA,QACA,UACA,mBACA,qBACA,sBACA,UACA,iBACA,SACA,gBACA,WACA,UACA,WACA,SACA,UACA,YACA,mBACA,aACA,UACA,UACA,YACA,mBACA,mBACA,YACA,cACA,UACA,eACA,mBACA,cACA,UACA,SACA,YACA,aACA,eACA,WACA,YACA,YACA,YACA,eACA,iBACA,YACA,UACA,iBACA,gBACA,gBACA,SACA,YACA,cACA,aACA,cACA,aACA,cACA,SACA,cACA,qBACA,eACA,eACA,cACA,aACA,cACA,YACA,mBACA,WACA,gBACA,aACA,cACA,eACA,WACA,UACA,kBACA,gBACA,iBACA,iBACA,gBACA,eACA,gBACA,cACA,sBACA,yBAOOI,EAAwBJ,EAAY,CAC3C,YACA,WACA,YACA,kBACA,MACA,YACA,SACA,UACA,KACA,OACA,MACA,OACA,QACA,WACA,QACA,YACA,aACA,SAOOK,EAAwBL,EAAYI,EAAuBD,GAM3DG,EAAkBN,EAAYK,EAAuB,CAC5D,SAOOE,EAAkBP,EAAYK,EAAuB,CAC5D,SACA,OACA,QACA,UACA,MACA,UAOOG,EAAkBR,EAAYO,EAAiB,CACtD,WAOOE,EAAeT,EAAYK,EAAuB,CACzD,UAOOK,EAAeV,EAAYK,EAAuB,CACzD,UAOOM,EAAmBX,EAAYK,EAAuB,CAC7D,WACA,OACA,WACA,QACA,MACA,SACA,SAOOO,EAAmBZ,EAAYK,EAAuB,CAC7D,YACA,WACA,OACA,aACA,cACA,aACA,iBACA,aACA,OACA,UAOOQ,EAAkBb,EAAYY,EAAkB,CACvD,SACA,MACA,iBACA,eACA,UACA,UACA,OACA,SACA,YACA,OACA,MACA,YACA,MACA,YACA,WACA,UACA,cACA,WACA,WACA,MACA,OACA,OACA,OACA,QACA,UAOOE,EAAqBd,EAAYY,EAAkB,CAC1D,iBACA,OACA,UACA,OACA,YACA,YACA,cACA,WACA,WACA,OACA,SAOOG,EAAmBf,EAAYY,EAAkB,CACxD,OACA,WACA,aAEOI,EAAmBhB,EAAYK,EAAuB,CAC7D,WACA,UAOOY,EA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","sources":["../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/Async.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/AutoScroll.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/BaseComponent.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/DelayedRender.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/EventGroup.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/FabricPerformance.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/GlobalSettings.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/KeyCodes.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/Rectangle.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/appendFunction.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/aria.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/array.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/asAsync.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/assertNever.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/classNamesFunction.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/componentAs/composeComponentAs.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/controlled.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/createMergedRef.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/css.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/Customizations.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/Customizer.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/CustomizerContext.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/shadowDom/hooks/useMergeStylesShadowRoot.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/shadowDom/contexts/MergeStylesShadowRootConsumer.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/customizable.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/mergeCustomizations.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/mergeSettings.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/customizations/useCustomizationSettings.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/canUseDOM.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/getDocument.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/getFirstVisibleElementFromSelector.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/getRect.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/getWindow.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/on.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/raiseClick.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/dom/setSSR.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/extendComponent.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/focus.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/getId.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/getNativeElementProps.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/getPropsWithDefaults.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/hoist.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/hoistStatics.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/ie11Detector.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/initializeComponentRef.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/initializeFocusRects.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/initials.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/keyboard.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/language.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/localStorage.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/math.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/memoize.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/merge.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/mobileDetector.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/modalize.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/object.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/osDetector.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/overflow.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/properties.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/renderFunction/composeRenderFunction.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/resources.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/rtl.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/safeRequestAnimationFrame.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/safeSetTimeout.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/scroll.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/selection/Selection.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/selection/Selection.types.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/sessionStorage.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/setFocusVisibility.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/shadowDom/contexts/MergeStylesShadowRootContext.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/shadowDom/contexts/MergeStylesDefaultContext.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/shadowDom/hooks/useMergeStylesHooks.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/string.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/styled.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/useFocusRects.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/warn/warn.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/warn/warnConditionallyRequiredProps.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/warn/warnControlledUsage.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/warn/warnDeprecations.js","../../../../node_modules/.pnpm/@fluentui+utilities@8.15.19_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/utilities/lib/warn/warnMutuallyExclusive.js"],"sourcesContent":["import { getWindow } from './dom/getWindow';\n/**\n * Bugs often appear in async code when stuff gets disposed, but async operations don't get canceled.\n * This Async helper class solves these issues by tying async code to the lifetime of a disposable object.\n *\n * Usage: Anything class extending from BaseModel can access this helper via this.async. Otherwise create a\n * new instance of the class and remember to call dispose() during your code's dispose handler.\n *\n * @public\n */\nvar Async = /** @class */ (function () {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function Async(parent, onError) {\n        this._timeoutIds = null;\n        this._immediateIds = null;\n        this._intervalIds = null;\n        this._animationFrameIds = null;\n        this._isDisposed = false;\n        this._parent = parent || null;\n        this._onErrorHandler = onError;\n        this._noop = function () {\n            /* do nothing */\n        };\n    }\n    /**\n     * Dispose function, clears all async operations.\n     */\n    Async.prototype.dispose = function () {\n        var id;\n        this._isDisposed = true;\n        this._parent = null;\n        // Clear timeouts.\n        if (this._timeoutIds) {\n            for (id in this._timeoutIds) {\n                if (this._timeoutIds.hasOwnProperty(id)) {\n                    this.clearTimeout(parseInt(id, 10));\n                }\n            }\n            this._timeoutIds = null;\n        }\n        // Clear immediates.\n        if (this._immediateIds) {\n            for (id in this._immediateIds) {\n                if (this._immediateIds.hasOwnProperty(id)) {\n                    this.clearImmediate(parseInt(id, 10));\n                }\n            }\n            this._immediateIds = null;\n        }\n        // Clear intervals.\n        if (this._intervalIds) {\n            for (id in this._intervalIds) {\n                if (this._intervalIds.hasOwnProperty(id)) {\n                    this.clearInterval(parseInt(id, 10));\n                }\n            }\n            this._intervalIds = null;\n        }\n        // Clear animation frames.\n        if (this._animationFrameIds) {\n            for (id in this._animationFrameIds) {\n                if (this._animationFrameIds.hasOwnProperty(id)) {\n                    this.cancelAnimationFrame(parseInt(id, 10));\n                }\n            }\n            this._animationFrameIds = null;\n        }\n    };\n    /**\n     * SetTimeout override, which will auto cancel the timeout during dispose.\n     * @param callback - Callback to execute.\n     * @param duration - Duration in milliseconds.\n     * @returns The setTimeout id.\n     */\n    Async.prototype.setTimeout = function (callback, duration) {\n        var _this = this;\n        var timeoutId = 0;\n        if (!this._isDisposed) {\n            if (!this._timeoutIds) {\n                this._timeoutIds = {};\n            }\n            timeoutId = setTimeout(function () {\n                // Time to execute the timeout, enqueue it as a foreground task to be executed.\n                try {\n                    // Now delete the record and call the callback.\n                    if (_this._timeoutIds) {\n                        delete _this._timeoutIds[timeoutId];\n                    }\n                    callback.apply(_this._parent);\n                }\n                catch (e) {\n                    _this._logError(e);\n                }\n            }, duration);\n            this._timeoutIds[timeoutId] = true;\n        }\n        return timeoutId;\n    };\n    /**\n     * Clears the timeout.\n     * @param id - Id to cancel.\n     */\n    Async.prototype.clearTimeout = function (id) {\n        if (this._timeoutIds && this._timeoutIds[id]) {\n            clearTimeout(id);\n            delete this._timeoutIds[id];\n        }\n    };\n    /**\n     * SetImmediate override, which will auto cancel the immediate during dispose.\n     * @param callback - Callback to execute.\n     * @param targetElement - Optional target element to use for identifying the correct window.\n     * @returns The setTimeout id.\n     */\n    Async.prototype.setImmediate = function (callback, targetElement) {\n        var _this = this;\n        var immediateId = 0;\n        var win = getWindow(targetElement);\n        if (!this._isDisposed) {\n            if (!this._immediateIds) {\n                this._immediateIds = {};\n            }\n            var setImmediateCallback = function () {\n                // Time to execute the timeout, enqueue it as a foreground task to be executed.\n                try {\n                    // Now delete the record and call the callback.\n                    if (_this._immediateIds) {\n                        delete _this._immediateIds[immediateId];\n                    }\n                    callback.apply(_this._parent);\n                }\n                catch (e) {\n                    _this._logError(e);\n                }\n            };\n            immediateId = win.setTimeout(setImmediateCallback, 0);\n            this._immediateIds[immediateId] = true;\n        }\n        return immediateId;\n    };\n    /**\n     * Clears the immediate.\n     * @param id - Id to cancel.\n     * @param targetElement - Optional target element to use for identifying the correct window.\n     */\n    Async.prototype.clearImmediate = function (id, targetElement) {\n        var win = getWindow(targetElement);\n        if (this._immediateIds && this._immediateIds[id]) {\n            win.clearTimeout(id);\n            delete this._immediateIds[id];\n        }\n    };\n    /**\n     * SetInterval override, which will auto cancel the timeout during dispose.\n     * @param callback - Callback to execute.\n     * @param duration - Duration in milliseconds.\n     * @returns The setTimeout id.\n     */\n    Async.prototype.setInterval = function (callback, duration) {\n        var _this = this;\n        var intervalId = 0;\n        if (!this._isDisposed) {\n            if (!this._intervalIds) {\n                this._intervalIds = {};\n            }\n            intervalId = setInterval(function () {\n                // Time to execute the interval callback, enqueue it as a foreground task to be executed.\n                try {\n                    callback.apply(_this._parent);\n                }\n                catch (e) {\n                    _this._logError(e);\n                }\n            }, duration);\n            this._intervalIds[intervalId] = true;\n        }\n        return intervalId;\n    };\n    /**\n     * Clears the interval.\n     * @param id - Id to cancel.\n     */\n    Async.prototype.clearInterval = function (id) {\n        if (this._intervalIds && this._intervalIds[id]) {\n            clearInterval(id);\n            delete this._intervalIds[id];\n        }\n    };\n    /**\n     * Creates a function that, when executed, will only call the func function at most once per\n     * every wait milliseconds. Provide an options object to indicate that func should be invoked\n     * on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled\n     * function will return the result of the last func call.\n     *\n     * Note: If leading and trailing options are true func will be called on the trailing edge of\n     * the timeout only if the throttled function is invoked more than once during the wait timeout.\n     *\n     * @param func - The function to throttle.\n     * @param wait - The number of milliseconds to throttle executions to. Defaults to 0.\n     * @param options - The options object.\n     * @returns The new throttled function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Async.prototype.throttle = function (func, wait, options) {\n        var _this = this;\n        if (this._isDisposed) {\n            return this._noop;\n        }\n        var waitMS = wait || 0;\n        var leading = true;\n        var trailing = true;\n        var lastExecuteTime = 0;\n        var lastResult;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var lastArgs;\n        var timeoutId = null;\n        if (options && typeof options.leading === 'boolean') {\n            leading = options.leading;\n        }\n        if (options && typeof options.trailing === 'boolean') {\n            trailing = options.trailing;\n        }\n        var callback = function (userCall) {\n            var now = Date.now();\n            var delta = now - lastExecuteTime;\n            var waitLength = leading ? waitMS - delta : waitMS;\n            if (delta >= waitMS && (!userCall || leading)) {\n                lastExecuteTime = now;\n                if (timeoutId) {\n                    _this.clearTimeout(timeoutId);\n                    timeoutId = null;\n                }\n                lastResult = func.apply(_this._parent, lastArgs);\n            }\n            else if (timeoutId === null && trailing) {\n                timeoutId = _this.setTimeout(callback, waitLength);\n            }\n            return lastResult;\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var resultFunction = (function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            lastArgs = args;\n            return callback(true);\n        });\n        return resultFunction;\n    };\n    /**\n     * Creates a function that will delay the execution of func until after wait milliseconds have\n     * elapsed since the last time it was invoked. Provide an options object to indicate that func\n     * should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls\n     * to the debounced function will return the result of the last func call.\n     *\n     * Note: If leading and trailing options are true func will be called on the trailing edge of\n     * the timeout only if the debounced function is invoked more than once during the wait\n     * timeout.\n     *\n     * @param func - The function to debounce.\n     * @param wait - The number of milliseconds to delay.\n     * @param options - The options object.\n     * @returns The new debounced function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Async.prototype.debounce = function (func, wait, options) {\n        var _this = this;\n        if (this._isDisposed) {\n            var noOpFunction = (function () {\n                /** Do nothing */\n            });\n            noOpFunction.cancel = function () {\n                return;\n            };\n            noOpFunction.flush = (function () { return null; });\n            noOpFunction.pending = function () { return false; };\n            return noOpFunction;\n        }\n        var waitMS = wait || 0;\n        var leading = false;\n        var trailing = true;\n        var maxWait = null;\n        var lastCallTime = 0;\n        var lastExecuteTime = Date.now();\n        var lastResult;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var lastArgs;\n        var timeoutId = null;\n        if (options && typeof options.leading === 'boolean') {\n            leading = options.leading;\n        }\n        if (options && typeof options.trailing === 'boolean') {\n            trailing = options.trailing;\n        }\n        if (options && typeof options.maxWait === 'number' && !isNaN(options.maxWait)) {\n            maxWait = options.maxWait;\n        }\n        var markExecuted = function (time) {\n            if (timeoutId) {\n                _this.clearTimeout(timeoutId);\n                timeoutId = null;\n            }\n            lastExecuteTime = time;\n        };\n        var invokeFunction = function (time) {\n            markExecuted(time);\n            lastResult = func.apply(_this._parent, lastArgs);\n        };\n        var callback = function (userCall) {\n            var now = Date.now();\n            var executeImmediately = false;\n            if (userCall) {\n                if (leading && now - lastCallTime >= waitMS) {\n                    executeImmediately = true;\n                }\n                lastCallTime = now;\n            }\n            var delta = now - lastCallTime;\n            var waitLength = waitMS - delta;\n            var maxWaitDelta = now - lastExecuteTime;\n            var maxWaitExpired = false;\n            if (maxWait !== null) {\n                // maxWait only matters when there is a pending callback\n                if (maxWaitDelta >= maxWait && timeoutId) {\n                    maxWaitExpired = true;\n                }\n                else {\n                    waitLength = Math.min(waitLength, maxWait - maxWaitDelta);\n                }\n            }\n            if (delta >= waitMS || maxWaitExpired || executeImmediately) {\n                invokeFunction(now);\n            }\n            else if ((timeoutId === null || !userCall) && trailing) {\n                timeoutId = _this.setTimeout(callback, waitLength);\n            }\n            return lastResult;\n        };\n        var pending = function () {\n            return !!timeoutId;\n        };\n        var cancel = function () {\n            if (pending()) {\n                // Mark the debounced function as having executed\n                markExecuted(Date.now());\n            }\n        };\n        var flush = function () {\n            if (pending()) {\n                invokeFunction(Date.now());\n            }\n            return lastResult;\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var resultFunction = (function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            lastArgs = args;\n            return callback(true);\n        });\n        resultFunction.cancel = cancel;\n        resultFunction.flush = flush;\n        resultFunction.pending = pending;\n        return resultFunction;\n    };\n    Async.prototype.requestAnimationFrame = function (callback, targetElement) {\n        var _this = this;\n        var animationFrameId = 0;\n        var win = getWindow(targetElement);\n        if (!this._isDisposed) {\n            if (!this._animationFrameIds) {\n                this._animationFrameIds = {};\n            }\n            var animationFrameCallback = function () {\n                try {\n                    // Now delete the record and call the callback.\n                    if (_this._animationFrameIds) {\n                        delete _this._animationFrameIds[animationFrameId];\n                    }\n                    callback.apply(_this._parent);\n                }\n                catch (e) {\n                    _this._logError(e);\n                }\n            };\n            animationFrameId = win.requestAnimationFrame\n                ? win.requestAnimationFrame(animationFrameCallback)\n                : win.setTimeout(animationFrameCallback, 0);\n            this._animationFrameIds[animationFrameId] = true;\n        }\n        return animationFrameId;\n    };\n    Async.prototype.cancelAnimationFrame = function (id, targetElement) {\n        var win = getWindow(targetElement);\n        if (this._animationFrameIds && this._animationFrameIds[id]) {\n            win.cancelAnimationFrame ? win.cancelAnimationFrame(id) : win.clearTimeout(id);\n            delete this._animationFrameIds[id];\n        }\n    };\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Async.prototype._logError = function (e) {\n        if (this._onErrorHandler) {\n            this._onErrorHandler(e);\n        }\n    };\n    return Async;\n}());\nexport { Async };\n//# sourceMappingURL=Async.js.map","import { EventGroup } from './EventGroup';\nimport { findScrollableParent } from './scroll';\nimport { getRect } from './dom/getRect';\nimport { getWindow } from './dom';\nvar SCROLL_ITERATION_DELAY = 16;\nvar SCROLL_GUTTER = 100;\nvar MAX_SCROLL_VELOCITY = 15;\n/**\n * AutoScroll simply hooks up mouse events given a parent element, and scrolls the container\n * up/down depending on how close the mouse is to the top/bottom of the container.\n *\n * Once you don't want autoscroll any more, just dispose the helper and it will unhook events.\n *\n * @public\n * {@docCategory AutoScroll}\n */\nvar AutoScroll = /** @class */ (function () {\n    function AutoScroll(element, win) {\n        var theWin = win !== null && win !== void 0 ? win : getWindow(element);\n        this._events = new EventGroup(this);\n        this._scrollableParent = findScrollableParent(element);\n        this._incrementScroll = this._incrementScroll.bind(this);\n        this._scrollRect = getRect(this._scrollableParent, theWin);\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (this._scrollableParent === theWin) {\n            this._scrollableParent = theWin.document.body;\n        }\n        if (this._scrollableParent) {\n            this._events.on(theWin, 'mousemove', this._onMouseMove, true);\n            this._events.on(theWin, 'touchmove', this._onTouchMove, true);\n        }\n    }\n    AutoScroll.prototype.dispose = function () {\n        this._events.dispose();\n        this._stopScroll();\n    };\n    AutoScroll.prototype._onMouseMove = function (ev) {\n        this._computeScrollVelocity(ev);\n    };\n    AutoScroll.prototype._onTouchMove = function (ev) {\n        if (ev.touches.length > 0) {\n            this._computeScrollVelocity(ev);\n        }\n    };\n    AutoScroll.prototype._computeScrollVelocity = function (ev) {\n        if (!this._scrollRect) {\n            return;\n        }\n        var clientX;\n        var clientY;\n        if ('clientX' in ev) {\n            clientX = ev.clientX;\n            clientY = ev.clientY;\n        }\n        else {\n            clientX = ev.touches[0].clientX;\n            clientY = ev.touches[0].clientY;\n        }\n        var scrollRectTop = this._scrollRect.top;\n        var scrollRectLeft = this._scrollRect.left;\n        var scrollClientBottom = scrollRectTop + this._scrollRect.height - SCROLL_GUTTER;\n        var scrollClientRight = scrollRectLeft + this._scrollRect.width - SCROLL_GUTTER;\n        // variables to use for alternating scroll direction\n        var scrollRect;\n        var clientDirection;\n        var scrollClient;\n        // if either of these conditions are met we are scrolling vertically else horizontally\n        if (clientY < scrollRectTop + SCROLL_GUTTER || clientY > scrollClientBottom) {\n            clientDirection = clientY;\n            scrollRect = scrollRectTop;\n            scrollClient = scrollClientBottom;\n            this._isVerticalScroll = true;\n        }\n        else {\n            clientDirection = clientX;\n            scrollRect = scrollRectLeft;\n            scrollClient = scrollClientRight;\n            this._isVerticalScroll = false;\n        }\n        // calculate scroll velocity and direction\n        if (clientDirection < scrollRect + SCROLL_GUTTER) {\n            this._scrollVelocity = Math.max(-MAX_SCROLL_VELOCITY, -MAX_SCROLL_VELOCITY * ((SCROLL_GUTTER - (clientDirection - scrollRect)) / SCROLL_GUTTER));\n        }\n        else if (clientDirection > scrollClient) {\n            this._scrollVelocity = Math.min(MAX_SCROLL_VELOCITY, MAX_SCROLL_VELOCITY * ((clientDirection - scrollClient) / SCROLL_GUTTER));\n        }\n        else {\n            this._scrollVelocity = 0;\n        }\n        if (this._scrollVelocity) {\n            this._startScroll();\n        }\n        else {\n            this._stopScroll();\n        }\n    };\n    AutoScroll.prototype._startScroll = function () {\n        if (!this._timeoutId) {\n            this._incrementScroll();\n        }\n    };\n    AutoScroll.prototype._incrementScroll = function () {\n        if (this._scrollableParent) {\n            if (this._isVerticalScroll) {\n                this._scrollableParent.scrollTop += Math.round(this._scrollVelocity);\n            }\n            else {\n                this._scrollableParent.scrollLeft += Math.round(this._scrollVelocity);\n            }\n        }\n        this._timeoutId = setTimeout(this._incrementScroll, SCROLL_ITERATION_DELAY);\n    };\n    AutoScroll.prototype._stopScroll = function () {\n        if (this._timeoutId) {\n            clearTimeout(this._timeoutId);\n            delete this._timeoutId;\n        }\n    };\n    return AutoScroll;\n}());\nexport { AutoScroll };\n//# sourceMappingURL=AutoScroll.js.map","import { __extends } from \"tslib\";\nimport * as React from 'react';\nimport { Async } from './Async';\nimport { EventGroup } from './EventGroup';\nimport { warnConditionallyRequiredProps } from './warn/warnConditionallyRequiredProps';\nimport { warnMutuallyExclusive } from './warn/warnMutuallyExclusive';\nimport { warnDeprecations } from './warn/warnDeprecations';\n/**\n * BaseComponent class, which provides basic helpers for all components.\n *\n * @public\n * {@docCategory BaseComponent}\n *\n * @deprecated Do not use. We are moving away from class component.\n */\nvar BaseComponent = /** @class */ (function (_super) {\n    __extends(BaseComponent, _super);\n    /**\n     * BaseComponent constructor\n     * @param props - The props for the component.\n     * @param context - The context for the component.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function BaseComponent(props, context) {\n        var _this = _super.call(this, props, context) || this;\n        // eslint-disable-next-line deprecation/deprecation\n        _makeAllSafe(_this, BaseComponent.prototype, [\n            'componentDidMount',\n            'shouldComponentUpdate',\n            'getSnapshotBeforeUpdate',\n            'render',\n            'componentDidUpdate',\n            'componentWillUnmount',\n        ]);\n        return _this;\n    }\n    /**\n     * When the component receives props, make sure the componentRef is updated.\n     */\n    BaseComponent.prototype.componentDidUpdate = function (prevProps, prevState) {\n        this._updateComponentRef(prevProps, this.props);\n    };\n    /**\n     * When the component has mounted, update the componentRef.\n     */\n    BaseComponent.prototype.componentDidMount = function () {\n        this._setComponentRef(this.props.componentRef, this);\n    };\n    /**\n     * If we have disposables, dispose them automatically on unmount.\n     */\n    BaseComponent.prototype.componentWillUnmount = function () {\n        this._setComponentRef(this.props.componentRef, null);\n        if (this.__disposables) {\n            for (var i = 0, len = this._disposables.length; i < len; i++) {\n                var disposable = this.__disposables[i];\n                if (disposable.dispose) {\n                    disposable.dispose();\n                }\n            }\n            this.__disposables = null;\n        }\n    };\n    Object.defineProperty(BaseComponent.prototype, \"className\", {\n        /**\n         * Gets the object's class name.\n         */\n        get: function () {\n            if (!this.__className) {\n                var funcNameRegex = /function (.{1,})\\(/;\n                var results = funcNameRegex.exec(this.constructor.toString());\n                this.__className = results && results.length > 1 ? results[1] : '';\n            }\n            return this.__className;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(BaseComponent.prototype, \"_disposables\", {\n        /**\n         * Allows subclasses to push things to this._disposables to be auto disposed.\n         */\n        get: function () {\n            if (!this.__disposables) {\n                this.__disposables = [];\n            }\n            return this.__disposables;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(BaseComponent.prototype, \"_async\", {\n        /**\n         * Gets the async instance associated with the component, created on demand. The async instance gives\n         * subclasses a way to execute setTimeout/setInterval async calls safely, where the callbacks\n         * will be cleared/ignored automatically after unmounting. The helpers within the async object also\n         * preserve the this pointer so that you don't need to \"bind\" the callbacks.\n         */\n        get: function () {\n            if (!this.__async) {\n                this.__async = new Async(this);\n                this._disposables.push(this.__async);\n            }\n            return this.__async;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(BaseComponent.prototype, \"_events\", {\n        /**\n         * Gets the event group instance assocaited with the component, created on demand. The event instance\n         * provides on/off methods for listening to DOM (or regular javascript object) events. The event callbacks\n         * will be automatically disconnected after unmounting. The helpers within the events object also\n         * preserve the this reference so that you don't need to \"bind\" the callbacks.\n         */\n        get: function () {\n            if (!this.__events) {\n                this.__events = new EventGroup(this);\n                this._disposables.push(this.__events);\n            }\n            return this.__events;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Helper to return a memoized ref resolver function.\n     * @param refName - Name of the member to assign the ref to.\n     * @returns A function instance keyed from the given refname.\n     * @deprecated Use `createRef` from React.createRef.\n     */\n    BaseComponent.prototype._resolveRef = function (refName) {\n        var _this = this;\n        if (!this.__resolves) {\n            this.__resolves = {};\n        }\n        if (!this.__resolves[refName]) {\n            this.__resolves[refName] = function (ref) {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                return (_this[refName] = ref);\n            };\n        }\n        return this.__resolves[refName];\n    };\n    /**\n     * Updates the componentRef (by calling it with \"this\" when necessary.)\n     */\n    BaseComponent.prototype._updateComponentRef = function (currentProps, newProps) {\n        if (newProps === void 0) { newProps = {}; }\n        // currentProps *should* always be defined, but verify that just in case a subclass is manually\n        // calling a lifecycle method with no parameters (which has happened) or other odd usage.\n        if (currentProps && newProps && currentProps.componentRef !== newProps.componentRef) {\n            this._setComponentRef(currentProps.componentRef, null);\n            this._setComponentRef(newProps.componentRef, this);\n        }\n    };\n    /**\n     * Warns when a deprecated props are being used.\n     *\n     * @param deprecationMap - The map of deprecations, where key is the prop name and the value is\n     * either null or a replacement prop name.\n     */\n    BaseComponent.prototype._warnDeprecations = function (deprecationMap) {\n        warnDeprecations(this.className, this.props, deprecationMap);\n    };\n    /**\n     * Warns when props which are mutually exclusive with each other are both used.\n     *\n     * @param mutuallyExclusiveMap - The map of mutually exclusive props.\n     */\n    BaseComponent.prototype._warnMutuallyExclusive = function (mutuallyExclusiveMap) {\n        warnMutuallyExclusive(this.className, this.props, mutuallyExclusiveMap);\n    };\n    /**\n     * Warns when props are required if a condition is met.\n     *\n     * @param requiredProps - The name of the props that are required when the condition is met.\n     * @param conditionalPropName - The name of the prop that the condition is based on.\n     * @param condition - Whether the condition is met.\n     */\n    BaseComponent.prototype._warnConditionallyRequiredProps = function (requiredProps, conditionalPropName, condition) {\n        warnConditionallyRequiredProps(this.className, this.props, requiredProps, conditionalPropName, condition);\n    };\n    BaseComponent.prototype._setComponentRef = function (ref, value) {\n        if (!this._skipComponentRefResolution && ref) {\n            if (typeof ref === 'function') {\n                ref(value);\n            }\n            if (typeof ref === 'object') {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                ref.current = value;\n            }\n        }\n    };\n    return BaseComponent;\n}(React.Component));\nexport { BaseComponent };\n/**\n * Helper to override a given method with a wrapper method that can try/catch the original, but also\n * ensures that the BaseComponent's methods are called before the subclass's. This ensures that\n * componentWillUnmount in the base is called and that things in the _disposables array are disposed.\n */\n// eslint-disable-next-line deprecation/deprecation\nfunction _makeAllSafe(obj, prototype, methodNames) {\n    for (var i = 0, len = methodNames.length; i < len; i++) {\n        _makeSafe(obj, prototype, methodNames[i]);\n    }\n}\n// eslint-disable-next-line deprecation/deprecation\nfunction _makeSafe(obj, prototype, methodName) {\n    /* eslint-disable @typescript-eslint/no-explicit-any */\n    var classMethod = obj[methodName];\n    var prototypeMethod = prototype[methodName];\n    if (classMethod || prototypeMethod) {\n        obj[methodName] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            /* eslint-enable @typescript-eslint/no-explicit-any */\n            var retVal;\n            if (prototypeMethod) {\n                retVal = prototypeMethod.apply(this, args);\n            }\n            if (classMethod !== prototypeMethod) {\n                retVal = classMethod.apply(this, args);\n            }\n            return retVal;\n        };\n    }\n}\n/**\n * Simple constant function for returning null, used to render empty templates in JSX.\n *\n * @public\n */\nexport function nullRender() {\n    return null;\n}\n//# sourceMappingURL=BaseComponent.js.map","import { __extends } from \"tslib\";\nimport * as React from 'react';\nimport { getWindow } from './dom/getWindow';\n/**\n * Utility component for delaying the render of a child component after a given delay. This component\n * requires a single child component; don't pass in many components. Wrap multiple components in a DIV\n * if necessary.\n *\n * @public\n * {@docCategory DelayedRender}\n */\nexport var DelayedRender = /** @class */ (function (_super) {\n    __extends(DelayedRender, _super);\n    function DelayedRender(props) {\n        var _this = _super.call(this, props) || this;\n        _this.state = {\n            isRendered: getWindow() === undefined,\n        };\n        return _this;\n    }\n    DelayedRender.prototype.componentDidMount = function () {\n        var _this = this;\n        var delay = this.props.delay;\n        // eslint-disable-next-line no-restricted-globals\n        this._timeoutId = window.setTimeout(function () {\n            _this.setState({\n                isRendered: true,\n            });\n        }, delay);\n    };\n    DelayedRender.prototype.componentWillUnmount = function () {\n        if (this._timeoutId) {\n            clearTimeout(this._timeoutId);\n        }\n    };\n    DelayedRender.prototype.render = function () {\n        return this.state.isRendered ? React.Children.only(this.props.children) : null;\n    };\n    DelayedRender.defaultProps = {\n        delay: 0,\n    };\n    return DelayedRender;\n}(React.Component));\n//# sourceMappingURL=DelayedRender.js.map","import { getDocument } from './dom';\nimport { assign } from './object';\n/** An instance of EventGroup allows anything with a handle to it to trigger events on it.\n *  If the target is an HTMLElement, the event will be attached to the element and can be\n *  triggered as usual (like clicking for onClick).\n *  The event can be triggered by calling EventGroup.raise() here. If the target is an\n *  HTMLElement, the event gets raised and is handled by the browser. Otherwise, it gets\n *  handled here in EventGroup, and the handler is called in the context of the parent\n *  (which is passed in in the constructor).\n *\n * @public\n * {@docCategory EventGroup}\n */\nexport var EventGroup = /** @class */ (function () {\n    /** parent: the context in which events attached to non-HTMLElements are called */\n    function EventGroup(parent) {\n        this._id = EventGroup._uniqueId++;\n        this._parent = parent;\n        this._eventRecords = [];\n    }\n    /** For IE8, bubbleEvent is ignored here and must be dealt with by the handler.\n     *  Events raised here by default have bubbling set to false and cancelable set to true.\n     *  This applies also to built-in events being raised manually here on HTMLElements,\n     *  which may lead to unexpected behavior if it differs from the defaults.\n     *\n     */\n    EventGroup.raise = function (target, eventName, eventArgs, bubbleEvent, doc) {\n        var retVal;\n        var theDoc = doc !== null && doc !== void 0 ? doc : getDocument();\n        if (EventGroup._isElement(target)) {\n            if (typeof theDoc !== 'undefined' && theDoc.createEvent) {\n                var ev = theDoc.createEvent('HTMLEvents');\n                // eslint-disable-next-line deprecation/deprecation\n                ev.initEvent(eventName, bubbleEvent || false, true);\n                assign(ev, eventArgs);\n                retVal = target.dispatchEvent(ev);\n            }\n            else if (typeof theDoc !== 'undefined' && theDoc.createEventObject) {\n                // IE8\n                var evObj = theDoc.createEventObject(eventArgs);\n                // cannot set cancelBubble on evObj, fireEvent will overwrite it\n                target.fireEvent('on' + eventName, evObj);\n            }\n        }\n        else {\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-ignore  -- FIXME: strictBindCallApply error - https://github.com/microsoft/fluentui/issues/17331\n            while (target && retVal !== false) {\n                var events = target.__events__;\n                var eventRecords = events ? events[eventName] : null;\n                if (eventRecords) {\n                    for (var id in eventRecords) {\n                        if (eventRecords.hasOwnProperty(id)) {\n                            var eventRecordList = eventRecords[id];\n                            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                            // @ts-ignore  -- FIXME: strictBindCallApply error - https://github.com/microsoft/fluentui/issues/17331\n                            for (var listIndex = 0; retVal !== false && listIndex < eventRecordList.length; listIndex++) {\n                                var record = eventRecordList[listIndex];\n                                if (record.objectCallback) {\n                                    retVal = record.objectCallback.call(record.parent, eventArgs);\n                                }\n                            }\n                        }\n                    }\n                }\n                // If the target has a parent, bubble the event up.\n                target = bubbleEvent ? target.parent : null;\n            }\n        }\n        return retVal;\n    };\n    EventGroup.isObserved = function (target, eventName) {\n        var events = target && target.__events__;\n        return !!events && !!events[eventName];\n    };\n    /** Check to see if the target has declared support of the given event. */\n    EventGroup.isDeclared = function (target, eventName) {\n        var declaredEvents = target && target.__declaredEvents;\n        return !!declaredEvents && !!declaredEvents[eventName];\n    };\n    EventGroup.stopPropagation = function (event) {\n        if (event.stopPropagation) {\n            event.stopPropagation();\n        }\n        else {\n            // IE8\n            event.cancelBubble = true;\n        }\n    };\n    EventGroup._isElement = function (target) {\n        return (!!target && (!!target.addEventListener || (typeof HTMLElement !== 'undefined' && target instanceof HTMLElement)));\n    };\n    EventGroup.prototype.dispose = function () {\n        if (!this._isDisposed) {\n            this._isDisposed = true;\n            this.off();\n            this._parent = null;\n        }\n    };\n    /** On the target, attach a set of events, where the events object is a name to function mapping. */\n    EventGroup.prototype.onAll = function (target, events, useCapture) {\n        for (var eventName in events) {\n            if (events.hasOwnProperty(eventName)) {\n                this.on(target, eventName, events[eventName], useCapture);\n            }\n        }\n    };\n    /**\n     * On the target, attach an event whose handler will be called in the context of the parent\n     * of this instance of EventGroup.\n     */\n    EventGroup.prototype.on = function (target, eventName, callback, options) {\n        var _this = this;\n        if (eventName.indexOf(',') > -1) {\n            var events = eventName.split(/[ ,]+/);\n            for (var i = 0; i < events.length; i++) {\n                this.on(target, events[i], callback, options);\n            }\n        }\n        else {\n            var parent_1 = this._parent;\n            var eventRecord = {\n                target: target,\n                eventName: eventName,\n                parent: parent_1,\n                callback: callback,\n                options: options,\n            };\n            // Initialize and wire up the record on the target, so that it can call the callback if the event fires.\n            var events = (target.__events__ = target.__events__ || {});\n            events[eventName] =\n                events[eventName] ||\n                    {\n                        count: 0,\n                    };\n            events[eventName][this._id] = events[eventName][this._id] || [];\n            events[eventName][this._id].push(eventRecord);\n            events[eventName].count++;\n            if (EventGroup._isElement(target)) {\n                var processElementEvent = function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    if (_this._isDisposed) {\n                        return;\n                    }\n                    var result;\n                    try {\n                        result = callback.apply(parent_1, args);\n                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                        // @ts-ignore  -- FIXME: strictBindCallApply error - https://github.com/microsoft/fluentui/issues/17331\n                        if (result === false && args[0]) {\n                            var e = args[0];\n                            if (e.preventDefault) {\n                                e.preventDefault();\n                            }\n                            if (e.stopPropagation) {\n                                e.stopPropagation();\n                            }\n                            e.cancelBubble = true;\n                        }\n                    }\n                    catch (e) {\n                        // ignore\n                    }\n                    return result;\n                };\n                eventRecord.elementCallback = processElementEvent;\n                if (target.addEventListener) {\n                    target.addEventListener(eventName, processElementEvent, options);\n                }\n                else if (target.attachEvent) {\n                    // IE8\n                    target.attachEvent('on' + eventName, processElementEvent);\n                }\n            }\n            else {\n                var processObjectEvent = function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    if (_this._isDisposed) {\n                        return;\n                    }\n                    return callback.apply(parent_1, args);\n                };\n                eventRecord.objectCallback = processObjectEvent;\n            }\n            // Remember the record locally, so that it can be removed.\n            this._eventRecords.push(eventRecord);\n        }\n    };\n    EventGroup.prototype.off = function (target, eventName, callback, options) {\n        for (var i = 0; i < this._eventRecords.length; i++) {\n            var eventRecord = this._eventRecords[i];\n            if ((!target || target === eventRecord.target) &&\n                (!eventName || eventName === eventRecord.eventName) &&\n                (!callback || callback === eventRecord.callback) &&\n                (typeof options !== 'boolean' || options === eventRecord.options)) {\n                var events = eventRecord.target.__events__;\n                var targetArrayLookup = events[eventRecord.eventName];\n                var targetArray = targetArrayLookup ? targetArrayLookup[this._id] : null;\n                // We may have already target's entries, so check for null.\n                if (targetArray) {\n                    if (targetArray.length === 1 || !callback) {\n                        targetArrayLookup.count -= targetArray.length;\n                        delete events[eventRecord.eventName][this._id];\n                    }\n                    else {\n                        targetArrayLookup.count--;\n                        targetArray.splice(targetArray.indexOf(eventRecord), 1);\n                    }\n                    if (!targetArrayLookup.count) {\n                        delete events[eventRecord.eventName];\n                    }\n                }\n                if (eventRecord.elementCallback) {\n                    if (eventRecord.target.removeEventListener) {\n                        eventRecord.target.removeEventListener(eventRecord.eventName, eventRecord.elementCallback, eventRecord.options);\n                    }\n                    else if (eventRecord.target.detachEvent) {\n                        // IE8\n                        eventRecord.target.detachEvent('on' + eventRecord.eventName, eventRecord.elementCallback);\n                    }\n                }\n                this._eventRecords.splice(i--, 1);\n            }\n        }\n    };\n    /** Trigger the given event in the context of this instance of EventGroup. */\n    EventGroup.prototype.raise = function (eventName, eventArgs, bubbleEvent) {\n        return EventGroup.raise(this._parent, eventName, eventArgs, bubbleEvent);\n    };\n    /** Declare an event as being supported by this instance of EventGroup. */\n    EventGroup.prototype.declare = function (event) {\n        var declaredEvents = (this._parent.__declaredEvents = this._parent.__declaredEvents || {});\n        if (typeof event === 'string') {\n            declaredEvents[event] = true;\n        }\n        else {\n            for (var i = 0; i < event.length; i++) {\n                declaredEvents[event[i]] = true;\n            }\n        }\n    };\n    EventGroup._uniqueId = 0;\n    return EventGroup;\n}());\n//# sourceMappingURL=EventGroup.js.map","var now = function () {\n    return typeof performance !== 'undefined' && !!performance.now ? performance.now() : Date.now();\n};\nvar RESET_INTERVAL = 3 * 60 * 1000; // auto reset every 3 minutes\n/**\n * Performance helper class for measuring things.\n *\n * @public\n * {@docCategory FabricPerformance}\n */\nexport var FabricPerformance = /** @class */ (function () {\n    function FabricPerformance() {\n    }\n    /**\n     * Measures execution time of the given syncronous function. If the same logic is executed multiple times,\n     * each individual measurement will be collected as well the overall numbers.\n     * @param name - The name of this measurement\n     * @param func - The logic to be measured for execution time\n     */\n    FabricPerformance.measure = function (name, func) {\n        if (FabricPerformance._timeoutId) {\n            FabricPerformance.setPeriodicReset();\n        }\n        var start = now();\n        func();\n        var end = now();\n        var measurement = FabricPerformance.summary[name] || {\n            totalDuration: 0,\n            count: 0,\n            all: [],\n        };\n        var duration = end - start;\n        measurement.totalDuration += duration;\n        measurement.count++;\n        measurement.all.push({\n            duration: duration,\n            timeStamp: end,\n        });\n        FabricPerformance.summary[name] = measurement;\n    };\n    FabricPerformance.reset = function () {\n        FabricPerformance.summary = {};\n        clearTimeout(FabricPerformance._timeoutId);\n        FabricPerformance._timeoutId = NaN;\n    };\n    FabricPerformance.setPeriodicReset = function () {\n        FabricPerformance._timeoutId = setTimeout(function () { return FabricPerformance.reset(); }, RESET_INTERVAL);\n    };\n    FabricPerformance.summary = {};\n    return FabricPerformance;\n}());\n//# sourceMappingURL=FabricPerformance.js.map","import { getWindow } from './dom/getWindow';\n/**\n * Storing global state in local module variables has issues when more than one copy\n * if the module gets loaded on the page (due to a bundling error or simply by consuming\n * a prebundled script.)\n *\n * This file contains helpers to deal with the getting and setting local state, and allows\n * callers to get called back when it mutates.\n */\nvar GLOBAL_SETTINGS_PROP_NAME = '__globalSettings__';\nvar CALLBACK_STATE_PROP_NAME = '__callbacks__';\nvar _counter = 0;\n/**\n * Global settings helper, which stores settings in the global (window) namespace.\n * If window is not provided, it will store settings in module scope. Provides a\n * way to observe changes as well when their values change.\n *\n * @public\n * {@docCategory GlobalSettings}\n */\nvar GlobalSettings = /** @class */ (function () {\n    function GlobalSettings() {\n    }\n    GlobalSettings.getValue = function (key, defaultValue) {\n        var globalSettings = _getGlobalSettings();\n        if (globalSettings[key] === undefined) {\n            globalSettings[key] = typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n        }\n        return globalSettings[key];\n    };\n    GlobalSettings.setValue = function (key, value) {\n        var globalSettings = _getGlobalSettings();\n        var callbacks = globalSettings[CALLBACK_STATE_PROP_NAME];\n        var oldValue = globalSettings[key];\n        if (value !== oldValue) {\n            globalSettings[key] = value;\n            var changeDescription = {\n                oldValue: oldValue,\n                value: value,\n                key: key,\n            };\n            for (var id in callbacks) {\n                if (callbacks.hasOwnProperty(id)) {\n                    callbacks[id](changeDescription);\n                }\n            }\n        }\n        return value;\n    };\n    GlobalSettings.addChangeListener = function (cb) {\n        // Note: we use generated ids on the callbacks to create a map of the callbacks, which optimizes removal.\n        // (It's faster to delete a key than it is to look up the index of an object and splice an array.)\n        var id = cb.__id__;\n        var callbacks = _getCallbacks();\n        if (!id) {\n            id = cb.__id__ = String(_counter++);\n        }\n        callbacks[id] = cb;\n    };\n    GlobalSettings.removeChangeListener = function (cb) {\n        var callbacks = _getCallbacks();\n        delete callbacks[cb.__id__];\n    };\n    return GlobalSettings;\n}());\nexport { GlobalSettings };\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _getGlobalSettings() {\n    var _a;\n    var win = getWindow();\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var globalObj = win || {};\n    if (!globalObj[GLOBAL_SETTINGS_PROP_NAME]) {\n        globalObj[GLOBAL_SETTINGS_PROP_NAME] = (_a = {},\n            _a[CALLBACK_STATE_PROP_NAME] = {},\n            _a);\n    }\n    return globalObj[GLOBAL_SETTINGS_PROP_NAME];\n}\nfunction _getCallbacks() {\n    var globalSettings = _getGlobalSettings();\n    return globalSettings[CALLBACK_STATE_PROP_NAME];\n}\n//# sourceMappingURL=GlobalSettings.js.map","/**\n * Simulated enum for keycodes. These will get inlined by uglify when used much like an enum\n *\n * @public\n * {@docCategory KeyCodes}\n */\nexport var KeyCodes = {\n    backspace: 8,\n    tab: 9,\n    enter: 13,\n    shift: 16,\n    ctrl: 17,\n    alt: 18,\n    pauseBreak: 19,\n    capslock: 20,\n    escape: 27,\n    space: 32,\n    pageUp: 33,\n    pageDown: 34,\n    end: 35,\n    home: 36,\n    left: 37,\n    up: 38,\n    right: 39,\n    down: 40,\n    insert: 45,\n    del: 46,\n    zero: 48,\n    one: 49,\n    two: 50,\n    three: 51,\n    four: 52,\n    five: 53,\n    six: 54,\n    seven: 55,\n    eight: 56,\n    nine: 57,\n    colon: 58,\n    a: 65,\n    b: 66,\n    c: 67,\n    d: 68,\n    e: 69,\n    f: 70,\n    g: 71,\n    h: 72,\n    i: 73,\n    j: 74,\n    k: 75,\n    l: 76,\n    m: 77,\n    n: 78,\n    o: 79,\n    p: 80,\n    q: 81,\n    r: 82,\n    s: 83,\n    t: 84,\n    u: 85,\n    v: 86,\n    w: 87,\n    x: 88,\n    y: 89,\n    z: 90,\n    leftWindow: 91,\n    rightWindow: 92,\n    select: 93,\n    /* eslint-disable @typescript-eslint/naming-convention */\n    zero_numpad: 96,\n    one_numpad: 97,\n    two_numpad: 98,\n    three_numpad: 99,\n    four_numpad: 100,\n    five_numpad: 101,\n    six_numpad: 102,\n    seven_numpad: 103,\n    eight_numpad: 104,\n    nine_numpad: 105,\n    /* eslint-enable @typescript-eslint/naming-convention */\n    multiply: 106,\n    add: 107,\n    subtract: 109,\n    decimalPoint: 110,\n    divide: 111,\n    f1: 112,\n    f2: 113,\n    f3: 114,\n    f4: 115,\n    f5: 116,\n    f6: 117,\n    f7: 118,\n    f8: 119,\n    f9: 120,\n    f10: 121,\n    f11: 122,\n    f12: 123,\n    numlock: 144,\n    scrollLock: 145,\n    semicolon: 186,\n    equalSign: 187,\n    comma: 188,\n    dash: 189,\n    period: 190,\n    forwardSlash: 191,\n    graveAccent: 192,\n    openBracket: 219,\n    backSlash: 220,\n    closeBracket: 221,\n    singleQuote: 222,\n};\n//# sourceMappingURL=KeyCodes.js.map","/**\n * Rectangle helper class.\n *\n * @public\n * {@docCategory Rectangle}\n */\nvar Rectangle = /** @class */ (function () {\n    function Rectangle(left, right, top, bottom) {\n        if (left === void 0) { left = 0; }\n        if (right === void 0) { right = 0; }\n        if (top === void 0) { top = 0; }\n        if (bottom === void 0) { bottom = 0; }\n        this.top = top;\n        this.bottom = bottom;\n        this.left = left;\n        this.right = right;\n    }\n    Object.defineProperty(Rectangle.prototype, \"width\", {\n        /**\n         * Calculated automatically by subtracting the right from left\n         */\n        get: function () {\n            return this.right - this.left;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Rectangle.prototype, \"height\", {\n        /**\n         * Calculated automatically by subtracting the bottom from top.\n         */\n        get: function () {\n            return this.bottom - this.top;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Tests if another rect is approximately equal to this rect (within 4 decimal places.)\n     */\n    Rectangle.prototype.equals = function (rect) {\n        // Fixing to 4 decimal places because it allows enough precision and will handle cases when something\n        // should be rounded, like .999999 should round to 1.\n        return (parseFloat(this.top.toFixed(4)) === parseFloat(rect.top.toFixed(4)) &&\n            parseFloat(this.bottom.toFixed(4)) === parseFloat(rect.bottom.toFixed(4)) &&\n            parseFloat(this.left.toFixed(4)) === parseFloat(rect.left.toFixed(4)) &&\n            parseFloat(this.right.toFixed(4)) === parseFloat(rect.right.toFixed(4)));\n    };\n    return Rectangle;\n}());\nexport { Rectangle };\n//# sourceMappingURL=Rectangle.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * Returns a single function which will call each of the given functions in the context of the\n * parent.\n */\nexport function appendFunction(parent) {\n    var functions = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        functions[_i - 1] = arguments[_i];\n    }\n    if (functions.length < 2) {\n        return functions[0];\n    }\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        functions.forEach(function (f) { return f && f.apply(parent, args); });\n    };\n}\n//# sourceMappingURL=appendFunction.js.map","/**\n * ARIA helper to concatenate attributes, returning undefined if all attributes\n * are undefined. (Empty strings are not a valid ARIA attribute value.)\n *\n * @param ariaAttributes - ARIA attributes to merge\n */\nexport function mergeAriaAttributeValues() {\n    var ariaAttributes = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        ariaAttributes[_i] = arguments[_i];\n    }\n    var mergedAttribute = ariaAttributes\n        .filter(function (arg) { return arg; })\n        .join(' ')\n        .trim();\n    return mergedAttribute === '' ? undefined : mergedAttribute;\n}\n//# sourceMappingURL=aria.js.map","/**\n * Helper to find the index of an item within an array, using a callback to\n * determine the match.\n *\n * @public\n * @param array - Array to search.\n * @param cb - Callback which returns true on matches.\n * @param fromIndex - Optional index to start from (defaults to 0)\n */\nexport function findIndex(array, cb, fromIndex) {\n    if (fromIndex === void 0) { fromIndex = 0; }\n    var index = -1;\n    for (var i = fromIndex; array && i < array.length; i++) {\n        if (cb(array[i], i)) {\n            index = i;\n            break;\n        }\n    }\n    return index;\n}\n/**\n * Helper to find the first item within an array that satisfies the callback.\n * @param array - Array to search\n * @param cb - Callback which returns true on matches\n */\nexport function find(array, cb) {\n    var index = findIndex(array, cb);\n    if (index < 0) {\n        return undefined;\n    }\n    return array[index];\n}\n/**\n * Creates an array of a given size and helper method to populate.\n *\n * @public\n * @param size - Size of array.\n * @param getItem - Callback to populate given cell index.\n */\nexport function createArray(size, getItem) {\n    var array = [];\n    for (var i = 0; i < size; i++) {\n        array.push(getItem(i));\n    }\n    return array;\n}\n/**\n * Convert the given array to a matrix with columnCount number\n * of columns.\n *\n * @public\n * @param items - The array to convert\n * @param columnCount - The number of columns for the resulting matrix\n * @returns A matrix of items\n */\nexport function toMatrix(items, columnCount) {\n    return items.reduce(function (rows, currentValue, index) {\n        if (index % columnCount === 0) {\n            rows.push([currentValue]);\n        }\n        else {\n            rows[rows.length - 1].push(currentValue);\n        }\n        return rows;\n    }, []);\n}\n/**\n * Given an array, it returns a new array that does not contain the item at the given index.\n * @param array - The array to operate on\n * @param index - The index of the element to remove\n */\nexport function removeIndex(array, index) {\n    return array.filter(function (_, i) { return index !== i; });\n}\n/**\n * Given an array, this function returns a new array where the element at a given index has been replaced.\n * @param array - The array to operate on\n * @param newElement - The element that will be placed in the new array\n * @param index - The index of the element that should be replaced\n */\nexport function replaceElement(array, newElement, index) {\n    var copy = array.slice();\n    copy[index] = newElement;\n    return copy;\n}\n/**\n * Given an array, this function returns a new array where an element has been inserted at the given index.\n * @param array - The array to operate on\n * @param index - The index where an element should be inserted\n * @param itemToAdd - The element to insert\n */\nexport function addElementAtIndex(array, index, itemToAdd) {\n    var copy = array.slice();\n    copy.splice(index, 0, itemToAdd);\n    return copy;\n}\n/**\n * Given an array where each element is of type T or T[], flatten it into an array of T\n * @param array - The array where each element can optionally also be an array\n */\nexport function flatten(array) {\n    var result = [];\n    array.forEach(function (item) { return (result = result.concat(item)); });\n    return result;\n}\n/**\n * Returns a boolean indicating if the two given arrays are equal in length and values.\n *\n * @param array1 - First array to compare\n * @param array2 - Second array to compare\n * @returns True if the arrays are the same length and have the same values in the same positions, false otherwise.\n */\nexport function arraysEqual(array1, array2) {\n    if (array1.length !== array2.length) {\n        return false;\n    }\n    for (var i = 0; i < array1.length; i++) {\n        if (array1[i] !== array2[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n//# sourceMappingURL=array.js.map","/**\n * asAsync - a HOC for async loading components.\n *\n * Usage:\n *\n * const AsyncDialog = asAsync({\n *   load: () => import('Dialog').then(result => result.default),\n * });\n *\n * React.render(domElement, <AsyncDialog asyncPlaceholder={ () => <Spinner/> } { ...dialogProps } />);\n *\n * Note the `asyncPlaceholder` prop will be respected when rendering the async component and it hasn't\n * been loaded yet.\n */\nimport { __assign, __extends, __rest } from \"tslib\";\nimport * as React from 'react';\n/**\n * If possible, use a WeakMap to maintain a cache of loaded components.\n * This can be used to synchronously render components that have already been loaded,\n * rather than having to wait for at least one async tick.\n */\nvar _syncModuleCache = typeof WeakMap !== 'undefined'\n    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        new WeakMap()\n    : undefined;\n/**\n * Produces a component which internally loads the target component before first mount.\n * The component passes all props through to the loaded component.\n *\n * This overload accepts a module with a default export for the component.\n */\nexport function asAsync(options) {\n    var Async = /** @class */ (function (_super) {\n        __extends(Async, _super);\n        function Async() {\n            var _this = _super !== null && _super.apply(this, arguments) || this;\n            _this.state = {\n                Component: _syncModuleCache ? _syncModuleCache.get(options.load) : undefined,\n            };\n            return _this;\n        }\n        Async.prototype.render = function () {\n            // Typescript issue: the rest can't be pulled without the any cast, as TypeScript fails with rest on generics.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            var _a = this.props, forwardedRef = _a.forwardedRef, Placeholder = _a.asyncPlaceholder, rest = __rest(_a, [\"forwardedRef\", \"asyncPlaceholder\"]);\n            var Component = this.state.Component;\n            return Component ? (React.createElement(Component, __assign(__assign({}, rest), { ref: forwardedRef }))) : Placeholder ? (React.createElement(Placeholder, null)) : null;\n        };\n        Async.prototype.componentDidMount = function () {\n            var _this = this;\n            var Component = this.state.Component;\n            if (!Component) {\n                options\n                    .load()\n                    .then(function (LoadedComponent) {\n                    if (LoadedComponent) {\n                        // Cache component for future reference.\n                        _syncModuleCache && _syncModuleCache.set(options.load, LoadedComponent);\n                        // Set state.\n                        _this.setState({\n                            Component: LoadedComponent,\n                        }, options.onLoad);\n                    }\n                })\n                    .catch(options.onError);\n            }\n        };\n        return Async;\n    }(React.Component));\n    return React.forwardRef(function (props, ref) { return React.createElement(Async, __assign({}, props, { forwardedRef: ref })); });\n}\n//# sourceMappingURL=asAsync.js.map","/**\n * AssertNever is a utility function that can be used for exhaustiveness checks in switch statements.\n *\n * @public\n */\nexport function assertNever(x) {\n    throw new Error('Unexpected object: ' + x);\n}\n//# sourceMappingURL=assertNever.js.map","import { mergeCssSets, Stylesheet } from '@fluentui/merge-styles';\nimport { getRTL } from './rtl';\nimport { getWindow } from './dom';\nvar MAX_CACHE_COUNT = 50;\nvar DEFAULT_SPECIFICITY_MULTIPLIER = 5;\nvar _memoizedClassNames = 0;\nvar stylesheet = Stylesheet.getInstance();\nif (stylesheet && stylesheet.onReset) {\n    stylesheet.onReset(function () { return _memoizedClassNames++; });\n}\n// Note that because of the caching nature within the classNames memoization,\n// I've disabled this rule to simply be able to work with any types.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n// This represents a prop we attach to each Map to indicate the cached return value\n// associated with the graph node.\nvar retVal = '__retval__';\n/**\n * Creates a getClassNames function which calls getStyles given the props, and injects them\n * into mergeStyleSets.\n *\n * Note that the props you pass in on every render should be in the same order and\n * immutable (numbers, strings, and booleans). This will allow the results to be memoized. Violating\n * these will cause extra recalcs to occur.\n */\nexport function classNamesFunction(options) {\n    // We build a trie where each node is a Map. The map entry key represents an argument\n    // value, and the entry value is another node (Map). Each node has a `__retval__`\n    // property which is used to hold the cached response.\n    if (options === void 0) { options = {}; }\n    // To derive the response, we can simply ensure the arguments are added or already\n    // exist in the trie. At the last node, if there is a `__retval__` we return that. Otherwise\n    // we call the `getStyles` api to evaluate, cache on the property, and return that.\n    // let map: IRecursiveMemoNode = new Map();\n    var windowMap = new Map();\n    var styleCalcCount = 0;\n    var getClassNamesCount = 0;\n    var currentMemoizedClassNames = _memoizedClassNames;\n    var getClassNames = function (styleFunctionOrObject, styleProps) {\n        var _a;\n        if (styleProps === void 0) { styleProps = {}; }\n        // If useStaticStyles is true, styleFunctionOrObject returns slot to classname mappings.\n        // If there is also no style overrides, we can skip merge styles completely and\n        // simply return the result from the style funcion.\n        if (options.useStaticStyles &&\n            typeof styleFunctionOrObject === 'function' &&\n            styleFunctionOrObject.__noStyleOverride__) {\n            return styleFunctionOrObject(styleProps);\n        }\n        getClassNamesCount++;\n        var shadowConfig = styleFunctionOrObject\n            ? styleFunctionOrObject.__shadowConfig__\n            : undefined;\n        var key = shadowConfig && shadowConfig.window ? shadowConfig.window : '__default__';\n        if (!windowMap.has(key)) {\n            windowMap.set(key, new Map());\n        }\n        var current = windowMap.get(key);\n        // let current: Map<any, any> = map;\n        var theme = styleProps.theme;\n        var rtl = theme && theme.rtl !== undefined ? theme.rtl : getRTL();\n        var disableCaching = options.disableCaching;\n        // On reset of our stylesheet, reset memoized cache.\n        if (currentMemoizedClassNames !== _memoizedClassNames) {\n            currentMemoizedClassNames = _memoizedClassNames;\n            // map = new Map();\n            windowMap.set(key, new Map());\n            current = windowMap.get(key);\n            styleCalcCount = 0;\n        }\n        if (!options.disableCaching) {\n            current = _traverseMap(windowMap.get(key), styleFunctionOrObject);\n            current = _traverseMap(current, styleProps);\n        }\n        if (disableCaching || !current[retVal]) {\n            if (styleFunctionOrObject === undefined) {\n                current[retVal] = {};\n            }\n            else {\n                current[retVal] = mergeCssSets([\n                    (typeof styleFunctionOrObject === 'function'\n                        ? styleFunctionOrObject(styleProps)\n                        : styleFunctionOrObject),\n                ], {\n                    shadowConfig: styleFunctionOrObject.__shadowConfig__,\n                    rtl: !!rtl,\n                    specificityMultiplier: options.useStaticStyles ? DEFAULT_SPECIFICITY_MULTIPLIER : undefined,\n                });\n            }\n            if (!disableCaching) {\n                styleCalcCount++;\n            }\n        }\n        if (styleCalcCount > (options.cacheSize || MAX_CACHE_COUNT)) {\n            var win = getWindow();\n            if ((_a = win === null || win === void 0 ? void 0 : win.FabricConfig) === null || _a === void 0 ? void 0 : _a.enableClassNameCacheFullWarning) {\n                // eslint-disable-next-line no-console\n                console.warn(\"Styles are being recalculated too frequently. Cache miss rate is \".concat(styleCalcCount, \"/\").concat(getClassNamesCount, \".\"));\n                // eslint-disable-next-line no-console\n                console.trace();\n            }\n            windowMap.get(key).clear();\n            styleCalcCount = 0;\n            // Mutate the options passed in, that's all we can do.\n            options.disableCaching = true;\n        }\n        // Note: the retVal is an attached property on the Map; not a key in the Map. We use this attached property to\n        // cache the return value for this branch of the graph.\n        return current[retVal];\n    };\n    return getClassNames;\n}\nfunction _traverseEdge(current, value) {\n    value = _normalizeValue(value);\n    if (!current.has(value)) {\n        current.set(value, new Map());\n    }\n    return current.get(value);\n}\nfunction _traverseMap(current, inputs) {\n    if (typeof inputs === 'function') {\n        var cachedInputsFromStyled = inputs.__cachedInputs__;\n        if (cachedInputsFromStyled) {\n            // The styled helper will generate the styles function and will attach the cached\n            // inputs (consisting of the default styles, customzied styles, and user provided styles.)\n            // These should be used as cache keys for deriving the memoized value.\n            for (var _i = 0, _a = inputs.__cachedInputs__; _i < _a.length; _i++) {\n                var input = _a[_i];\n                current = _traverseEdge(current, input);\n            }\n        }\n        else {\n            current = _traverseEdge(current, inputs);\n        }\n    }\n    else if (typeof inputs === 'object') {\n        for (var propName in inputs) {\n            if (inputs.hasOwnProperty(propName)) {\n                current = _traverseEdge(current, inputs[propName]);\n            }\n        }\n    }\n    return current;\n}\nfunction _normalizeValue(value) {\n    switch (value) {\n        case undefined:\n            return '__undefined__';\n        case null:\n            return '__null__';\n        default:\n            return value;\n    }\n}\n//# sourceMappingURL=classNamesFunction.js.map","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { createMemoizer } from '../memoize';\nfunction createComposedComponent(outer) {\n    var Outer = outer;\n    var outerMemoizer = createMemoizer(function (inner) {\n        if (outer === inner) {\n            throw new Error('Attempted to compose a component with itself.');\n        }\n        var Inner = inner;\n        var innerMemoizer = createMemoizer(function (defaultRender) {\n            var InnerWithDefaultRender = function (innerProps) {\n                return React.createElement(Inner, __assign({}, innerProps, { defaultRender: defaultRender }));\n            };\n            return InnerWithDefaultRender;\n        });\n        var OuterWithDefaultRender = function (outerProps) {\n            var defaultRender = outerProps.defaultRender;\n            return React.createElement(Outer, __assign({}, outerProps, { defaultRender: defaultRender ? innerMemoizer(defaultRender) : Inner }));\n        };\n        return OuterWithDefaultRender;\n    });\n    return outerMemoizer;\n}\nvar componentAsMemoizer = createMemoizer(createComposedComponent);\n/**\n * Composes two components which conform to the `IComponentAs` specification; that is, two\n * components which accept a `defaultRender` prop, which is a 'default' implementation of\n * a component which accepts the same overall props.\n *\n * @public\n */\nexport function composeComponentAs(outer, inner) {\n    return componentAsMemoizer(outer)(inner);\n}\n//# sourceMappingURL=composeComponentAs.js.map","/**\n * Determines whether a component is controlled.\n * @param props - Component props\n * @param valueProp - Prop containing the controlled value\n * @returns true if controlled, false if uncontrolled\n */\nexport function isControlled(props, valueProp) {\n    // React's built-in <input> considers a prop to be provided if its value is non-null/undefined.\n    // Mirror that behavior here (rather than checking for just undefined).\n    return props[valueProp] !== undefined && props[valueProp] !== null;\n}\n//# sourceMappingURL=controlled.js.map","import { arraysEqual } from './array';\n/**\n * Set up a ref resolver function given internal state managed for the ref.\n * @param local Set\n */\nvar createResolver = function (local) {\n    return function (newValue) {\n        for (var _i = 0, _a = local.refs; _i < _a.length; _i++) {\n            var ref = _a[_i];\n            if (typeof ref === 'function') {\n                ref(newValue);\n            }\n            else if (ref) {\n                // work around the immutability of the React.Ref type\n                ref.current = newValue;\n            }\n        }\n    };\n};\n/**\n * Helper to merge refs from within class components.\n */\nexport var createMergedRef = function (value) {\n    var local = {\n        refs: [],\n    };\n    return function () {\n        var newRefs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newRefs[_i] = arguments[_i];\n        }\n        if (!local.resolver || !arraysEqual(local.refs, newRefs)) {\n            local.resolver = createResolver(local);\n        }\n        local.refs = newRefs;\n        return local.resolver;\n    };\n};\n//# sourceMappingURL=createMergedRef.js.map","/**\n * Concatination helper, which can merge class names together. Skips over falsey values.\n *\n * @public\n */\nexport function css() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var classes = [];\n    for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {\n        var arg = args_1[_a];\n        if (arg) {\n            if (typeof arg === 'string') {\n                classes.push(arg);\n            }\n            else if (arg.hasOwnProperty('toString') && typeof arg.toString === 'function') {\n                classes.push(arg.toString());\n            }\n            else {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                for (var key in arg) {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    if (arg[key]) {\n                        classes.push(key);\n                    }\n                }\n            }\n        }\n    }\n    return classes.join(' ');\n}\n//# sourceMappingURL=css.js.map","import { __assign } from \"tslib\";\nimport { GlobalSettings } from '../GlobalSettings';\nvar CustomizationsGlobalKey = 'customizations';\nvar NO_CUSTOMIZATIONS = { settings: {}, scopedSettings: {}, inCustomizerContext: false };\nvar _allSettings = GlobalSettings.getValue(CustomizationsGlobalKey, {\n    settings: {},\n    scopedSettings: {},\n    inCustomizerContext: false,\n});\nvar _events = [];\nvar Customizations = /** @class */ (function () {\n    function Customizations() {\n    }\n    Customizations.reset = function () {\n        _allSettings.settings = {};\n        _allSettings.scopedSettings = {};\n    };\n    /** Apply global Customization settings.\n     * @example Customizations.applySettings(\\{ theme: \\{...\\} \\});\n     */\n    Customizations.applySettings = function (settings) {\n        _allSettings.settings = __assign(__assign({}, _allSettings.settings), settings);\n        Customizations._raiseChange();\n    };\n    /** Apply Customizations to a particular named scope, like a component.\n     * @example Customizations.applyScopedSettings('Nav', \\{ styles: () =\\> \\{\\} \\});\n     */\n    Customizations.applyScopedSettings = function (scopeName, settings) {\n        _allSettings.scopedSettings[scopeName] = __assign(__assign({}, _allSettings.scopedSettings[scopeName]), settings);\n        Customizations._raiseChange();\n    };\n    Customizations.getSettings = function (properties, scopeName, localSettings) {\n        if (localSettings === void 0) { localSettings = NO_CUSTOMIZATIONS; }\n        var settings = {};\n        var localScopedSettings = (scopeName && localSettings.scopedSettings[scopeName]) || {};\n        var globalScopedSettings = (scopeName && _allSettings.scopedSettings[scopeName]) || {};\n        for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {\n            var property = properties_1[_i];\n            settings[property] =\n                localScopedSettings[property] ||\n                    localSettings.settings[property] ||\n                    globalScopedSettings[property] ||\n                    _allSettings.settings[property];\n        }\n        return settings;\n    };\n    /** Used to run some code that sets Customizations without triggering an update until the end.\n     * Useful for applying Customizations that don't affect anything currently rendered, or for\n     * applying many customizations at once.\n     * @param suppressUpdate - Do not raise the change event at the end, preventing all updates\n     */\n    Customizations.applyBatchedUpdates = function (code, suppressUpdate) {\n        Customizations._suppressUpdates = true;\n        try {\n            code();\n        }\n        catch (_a) {\n            /* do nothing */\n        }\n        Customizations._suppressUpdates = false;\n        if (!suppressUpdate) {\n            Customizations._raiseChange();\n        }\n    };\n    Customizations.observe = function (onChange) {\n        _events.push(onChange);\n    };\n    Customizations.unobserve = function (onChange) {\n        _events = _events.filter(function (cb) { return cb !== onChange; });\n    };\n    Customizations._raiseChange = function () {\n        if (!Customizations._suppressUpdates) {\n            _events.forEach(function (cb) { return cb(); });\n        }\n    };\n    return Customizations;\n}());\nexport { Customizations };\n//# sourceMappingURL=Customizations.js.map","import { __extends } from \"tslib\";\nimport * as React from 'react';\nimport { Customizations } from './Customizations';\nimport { CustomizerContext } from './CustomizerContext';\nimport { mergeCustomizations } from './mergeCustomizations';\n/**\n * The Customizer component allows for default props to be mixed into components which\n * are decorated with the customizable() decorator, or use the styled HOC. This enables\n * injection scenarios like:\n *\n * 1. render svg icons instead of the icon font within all buttons\n * 2. inject a custom theme object into a component\n *\n * Props are provided via the settings prop which should be one of the following:\n * - A json map which contains 1 or more name/value pairs representing injectable props.\n * - A function that receives the current settings and returns the new ones that apply to the scope\n *\n * @public\n *\n * @deprecated This component is deprecated for purpose of applying theme to components\n * as of `@fluentui/react` version 8. Use `ThemeProvider` for applying theme instead.\n */\nvar Customizer = /** @class */ (function (_super) {\n    __extends(Customizer, _super);\n    function Customizer() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this._onCustomizationChange = function () { return _this.forceUpdate(); };\n        return _this;\n    }\n    Customizer.prototype.componentDidMount = function () {\n        Customizations.observe(this._onCustomizationChange);\n    };\n    Customizer.prototype.componentWillUnmount = function () {\n        Customizations.unobserve(this._onCustomizationChange);\n    };\n    Customizer.prototype.render = function () {\n        var _this = this;\n        var contextTransform = this.props.contextTransform;\n        return (React.createElement(CustomizerContext.Consumer, null, function (parentContext) {\n            var newContext = mergeCustomizations(_this.props, parentContext);\n            if (contextTransform) {\n                newContext = contextTransform(newContext);\n            }\n            return React.createElement(CustomizerContext.Provider, { value: newContext }, _this.props.children);\n        }));\n    };\n    return Customizer;\n}(React.Component));\nexport { Customizer };\n//# sourceMappingURL=Customizer.js.map","import * as React from 'react';\nexport var CustomizerContext = React.createContext({\n    customizations: {\n        inCustomizerContext: false,\n        settings: {},\n        scopedSettings: {},\n    },\n});\n//# sourceMappingURL=CustomizerContext.js.map","import * as React from 'react';\nimport { MergeStylesShadowRootContext, } from '../contexts/MergeStylesShadowRootContext';\n/**\n * Test if a context is available.\n * @returns true if there is a context.\n */\nexport var useHasMergeStylesShadowRootContext = function () {\n    return !!useMergeStylesShadowRootContext();\n};\n/**\n * Get a reference to the shadow root context.\n * @returns The context for the shadow root.\n */\nexport var useMergeStylesShadowRootContext = function () {\n    return React.useContext(MergeStylesShadowRootContext);\n};\n//# sourceMappingURL=useMergeStylesShadowRoot.js.map","import { GLOBAL_STYLESHEET_KEY } from '@fluentui/merge-styles';\nimport { useMergeStylesHooks } from '../hooks/useMergeStylesHooks';\nimport { useMergeStylesShadowRootContext } from '../hooks/useMergeStylesShadowRoot';\nexport var MergeStylesShadowRootConsumer = function (_a) {\n    var stylesheetKey = _a.stylesheetKey, children = _a.children;\n    var _b = useMergeStylesHooks(), useAdoptedStylesheetEx = _b.useAdoptedStylesheetEx, useMergeStylesRootStylesheets = _b.useMergeStylesRootStylesheets, useWindow = _b.useWindow;\n    var shadowCtx = useMergeStylesShadowRootContext();\n    var rootMergeStyles = useMergeStylesRootStylesheets();\n    var win = useWindow();\n    useAdoptedStylesheetEx(GLOBAL_STYLESHEET_KEY, shadowCtx, rootMergeStyles, win);\n    useAdoptedStylesheetEx(stylesheetKey, shadowCtx, rootMergeStyles, win);\n    return children(!!shadowCtx);\n};\n//# sourceMappingURL=MergeStylesShadowRootConsumer.js.map","import { __assign, __extends } from \"tslib\";\nimport * as React from 'react';\nimport { Customizations } from './Customizations';\nimport { hoistStatics } from '../hoistStatics';\nimport { CustomizerContext } from './CustomizerContext';\nimport { concatStyleSets, makeShadowConfig } from '@fluentui/merge-styles';\nimport { MergeStylesShadowRootConsumer } from '../shadowDom/contexts/MergeStylesShadowRootConsumer';\nimport { getWindow } from '../dom/getWindow';\nimport { WindowContext } from '@fluentui/react-window-provider';\nimport { memoizeFunction } from '../memoize';\nvar memoizedMakeShadowConfig = memoizeFunction(makeShadowConfig);\nvar mergeComponentStyles = memoizeFunction(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction (defaultStyles, componentStyles, shadowConfig) {\n    var _a;\n    var styles = (_a = componentStyles !== null && componentStyles !== void 0 ? componentStyles : defaultStyles) !== null && _a !== void 0 ? _a : {};\n    styles.__shadowConfig__ = shadowConfig;\n    return styles;\n});\nexport function customizable(scope, fields, concatStyles) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return function customizableFactory(ComposedComponent) {\n        var _a;\n        var resultClass = (_a = /** @class */ (function (_super) {\n                __extends(ComponentWithInjectedProps, _super);\n                function ComponentWithInjectedProps(props) {\n                    var _this = _super.call(this, props) || this;\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    _this._styleCache = {};\n                    _this._onSettingChanged = _this._onSettingChanged.bind(_this);\n                    return _this;\n                }\n                ComponentWithInjectedProps.prototype.componentDidMount = function () {\n                    Customizations.observe(this._onSettingChanged);\n                };\n                ComponentWithInjectedProps.prototype.componentWillUnmount = function () {\n                    Customizations.unobserve(this._onSettingChanged);\n                };\n                ComponentWithInjectedProps.prototype.render = function () {\n                    var _this = this;\n                    return (React.createElement(MergeStylesShadowRootConsumer, { stylesheetKey: scope }, function (inShadow) {\n                        return (React.createElement(CustomizerContext.Consumer, null, function (context) {\n                            var _a;\n                            var defaultProps = Customizations.getSettings(fields, scope, context.customizations);\n                            var win = (_a = _this.context.window) !== null && _a !== void 0 ? _a : getWindow();\n                            var shadowConfig = memoizedMakeShadowConfig(scope, inShadow, win);\n                            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                            var componentProps = _this.props;\n                            // If defaultProps.styles is a function, evaluate it before calling concatStyleSets\n                            if (defaultProps.styles && typeof defaultProps.styles === 'function') {\n                                defaultProps.styles = defaultProps.styles(__assign(__assign({}, defaultProps), componentProps));\n                            }\n                            // If concatStyles is true and custom styles have been defined compute those styles\n                            if (concatStyles && defaultProps.styles) {\n                                if (_this._styleCache.default !== defaultProps.styles ||\n                                    _this._styleCache.component !== componentProps.styles) {\n                                    var mergedStyles = concatStyleSets(defaultProps.styles, componentProps.styles);\n                                    mergedStyles.__shadowConfig__ = shadowConfig;\n                                    _this._styleCache.default = defaultProps.styles;\n                                    _this._styleCache.component = componentProps.styles;\n                                    _this._styleCache.merged = mergedStyles;\n                                }\n                                return (React.createElement(ComposedComponent, __assign({}, defaultProps, componentProps, { styles: _this._styleCache.merged })));\n                            }\n                            var styles = mergeComponentStyles(defaultProps.styles, componentProps.styles, shadowConfig);\n                            return React.createElement(ComposedComponent, __assign({}, defaultProps, componentProps, { styles: styles }));\n                        }));\n                    }));\n                };\n                ComponentWithInjectedProps.prototype._onSettingChanged = function () {\n                    this.forceUpdate();\n                };\n                return ComponentWithInjectedProps;\n            }(React.Component)),\n            _a.displayName = 'Customized' + scope,\n            _a.contextType = WindowContext,\n            _a);\n        return hoistStatics(ComposedComponent, resultClass);\n    };\n}\n//# sourceMappingURL=customizable.js.map","import { mergeSettings, mergeScopedSettings } from './mergeSettings';\n/**\n * Merge props and customizations giving priority to props over context.\n * NOTE: This function will always perform multiple merge operations. Use with caution.\n * @param props - New settings to merge in.\n * @param parentContext - Context containing current settings.\n * @returns Merged customizations.\n */\nexport function mergeCustomizations(props, parentContext) {\n    var _a = (parentContext || {}).customizations, customizations = _a === void 0 ? { settings: {}, scopedSettings: {} } : _a;\n    return {\n        customizations: {\n            settings: mergeSettings(customizations.settings, props.settings),\n            scopedSettings: mergeScopedSettings(customizations.scopedSettings, props.scopedSettings),\n            inCustomizerContext: true,\n        },\n    };\n}\n//# sourceMappingURL=mergeCustomizations.js.map","import { __assign } from \"tslib\";\n/**\n * Merge new and old settings, giving priority to new settings.\n * New settings is optional in which case oldSettings is returned as-is.\n * @param oldSettings - Old settings to fall back to.\n * @param newSettings - New settings that will be merged over oldSettings.\n * @returns Merged settings.\n */\nexport function mergeSettings(oldSettings, newSettings) {\n    if (oldSettings === void 0) { oldSettings = {}; }\n    var mergeSettingsWith = _isSettingsFunction(newSettings) ? newSettings : _settingsMergeWith(newSettings);\n    return mergeSettingsWith(oldSettings);\n}\nexport function mergeScopedSettings(oldSettings, newSettings) {\n    if (oldSettings === void 0) { oldSettings = {}; }\n    var mergeSettingsWith = _isSettingsFunction(newSettings) ? newSettings : _scopedSettingsMergeWith(newSettings);\n    return mergeSettingsWith(oldSettings);\n}\nfunction _isSettingsFunction(settings) {\n    return typeof settings === 'function';\n}\nfunction _settingsMergeWith(newSettings) {\n    return function (settings) { return (newSettings ? __assign(__assign({}, settings), newSettings) : settings); };\n}\nfunction _scopedSettingsMergeWith(scopedSettingsFromProps) {\n    if (scopedSettingsFromProps === void 0) { scopedSettingsFromProps = {}; }\n    return function (oldScopedSettings) {\n        var newScopedSettings = __assign({}, oldScopedSettings);\n        for (var scopeName in scopedSettingsFromProps) {\n            if (scopedSettingsFromProps.hasOwnProperty(scopeName)) {\n                newScopedSettings[scopeName] = __assign(__assign({}, oldScopedSettings[scopeName]), scopedSettingsFromProps[scopeName]);\n            }\n        }\n        return newScopedSettings;\n    };\n}\n//# sourceMappingURL=mergeSettings.js.map","import * as React from 'react';\nimport { Customizations } from './Customizations';\nimport { CustomizerContext } from './CustomizerContext';\n/**\n * Hook to get Customizations settings from Customizations singleton or CustomizerContext.\n * It will trigger component state update on settings change observed.\n */\nexport function useCustomizationSettings(properties, scopeName) {\n    var forceUpdate = useForceUpdate();\n    var customizations = React.useContext(CustomizerContext).customizations;\n    var inCustomizerContext = customizations.inCustomizerContext;\n    React.useEffect(function () {\n        if (!inCustomizerContext) {\n            Customizations.observe(forceUpdate);\n        }\n        return function () {\n            if (!inCustomizerContext) {\n                Customizations.unobserve(forceUpdate);\n            }\n        };\n        // eslint-disable-next-line react-hooks/exhaustive-deps -- exclude forceUpdate\n    }, [inCustomizerContext]);\n    return Customizations.getSettings(properties, scopeName, customizations);\n}\nfunction useForceUpdate() {\n    var _a = React.useState(0), setValue = _a[1];\n    return function () { return setValue(function (value) { return ++value; }); };\n}\n//# sourceMappingURL=useCustomizationSettings.js.map","/**\n * Verifies if an application can use DOM.\n */\nexport function canUseDOM() {\n    return (\n    // eslint-disable-next-line no-restricted-globals\n    typeof window !== 'undefined' &&\n        !!(\n        // eslint-disable-next-line no-restricted-globals, deprecation/deprecation\n        (window.document && window.document.createElement)));\n}\n//# sourceMappingURL=canUseDOM.js.map","import { canUseDOM } from './canUseDOM';\n/**\n * Helper to get the document object. Note that in popup window cases, document\n * might be the wrong document, which is why we look at ownerDocument for the\n * truth.\n *\n * @public\n */\nexport function getDocument(rootElement) {\n    // eslint-disable-next-line no-restricted-globals\n    if (!canUseDOM() || typeof document === 'undefined') {\n        return undefined;\n    }\n    else {\n        var el = rootElement;\n        // eslint-disable-next-line no-restricted-globals\n        return el && el.ownerDocument ? el.ownerDocument : document;\n    }\n}\n//# sourceMappingURL=getDocument.js.map","import { isElementVisibleAndNotHidden } from '../focus';\nimport { getDocument } from './getDocument';\n/**\n * Gets the first visible element that matches the given selector\n * @param selector - The selector to use to find potential visible elements\n * @returns The first visible element that matches the selector, otherwise undefined\n *\n * @public\n */\nexport function getFirstVisibleElementFromSelector(selector) {\n    var doc = getDocument();\n    var elements = doc.querySelectorAll(selector);\n    // Iterate across the elements that match the selector and return the first visible/non-hidden element\n    return Array.from(elements).find(function (element) { var _a; return isElementVisibleAndNotHidden(element, (_a = doc.defaultView) !== null && _a !== void 0 ? _a : undefined); });\n}\n//# sourceMappingURL=getFirstVisibleElementFromSelector.js.map","import { getWindow } from './getWindow';\n/**\n * Helper to get bounding client rect. Passing in window will get the window size.\n *\n * @public\n */\nexport function getRect(element, win) {\n    var theWin = (win !== null && win !== void 0 ? win : (!element || (element && element.hasOwnProperty('devicePixelRatio'))))\n        ? getWindow()\n        : getWindow(element);\n    var rect;\n    if (element) {\n        if (element === theWin) {\n            rect = {\n                left: 0,\n                top: 0,\n                width: theWin.innerWidth,\n                height: theWin.innerHeight,\n                right: theWin.innerWidth,\n                bottom: theWin.innerHeight,\n            };\n        }\n        else if (element.getBoundingClientRect) {\n            rect = element.getBoundingClientRect();\n        }\n    }\n    return rect;\n}\n//# sourceMappingURL=getRect.js.map","import { canUseDOM } from './canUseDOM';\nvar _window = undefined;\n// Note: Accessing \"window\" in IE11 is somewhat expensive, and calling \"typeof window\"\n// hits a memory leak, whereas aliasing it and calling \"typeof _window\" does not.\n// Caching the window value at the file scope lets us minimize the impact.\ntry {\n    // eslint-disable-next-line no-restricted-globals\n    _window = window;\n}\ncatch (e) {\n    /* no-op */\n}\n/**\n * Helper to get the window object. The helper will make sure to use a cached variable\n * of \"window\", to avoid overhead and memory leaks in IE11. Note that in popup scenarios the\n * window object won't match the \"global\" window object, and for these scenarios, you should\n * pass in an element hosted within the popup.\n *\n * @public\n */\nexport function getWindow(rootElement) {\n    if (!canUseDOM() || typeof _window === 'undefined') {\n        return undefined;\n    }\n    else {\n        var el = rootElement;\n        return el && el.ownerDocument && el.ownerDocument.defaultView ? el.ownerDocument.defaultView : _window;\n    }\n}\n//# sourceMappingURL=getWindow.js.map","export function on(element, eventName, callback, options) {\n    element.addEventListener(eventName, callback, options);\n    return function () { return element.removeEventListener(eventName, callback, options); };\n}\n//# sourceMappingURL=on.js.map","import { getDocument } from './getDocument';\n/** Raises a click event.\n * @deprecated Moved to `FocusZone` component since it was the only place internally using this function.\n */\nexport function raiseClick(target, doc) {\n    var theDoc = doc !== null && doc !== void 0 ? doc : getDocument();\n    var event = createNewEvent('MouseEvents', theDoc);\n    // eslint-disable-next-line deprecation/deprecation\n    event.initEvent('click', true, true);\n    target.dispatchEvent(event);\n}\nfunction createNewEvent(eventName, doc) {\n    var event;\n    if (typeof Event === 'function') {\n        // Chrome, Opera, Firefox\n        event = new Event(eventName);\n    }\n    else {\n        // IE\n        event = doc.createEvent('Event');\n        // eslint-disable-next-line deprecation/deprecation\n        event.initEvent(eventName, true, true);\n    }\n    return event;\n}\n//# sourceMappingURL=raiseClick.js.map","/**\n * @deprecated Use `canUseDOM` from `@fluentui/utilities` instead.\n */\nexport var _isSSR = false;\n/**\n * Helper to set ssr mode to simulate no window object returned from getWindow helper.\n *\n * @deprecated Use `canUseDOM` from `@fluentui/utilities` instead.\n */\nexport function setSSR(isEnabled) {\n    throw new Error('setSSR has been deprecated and is not used in any utilities anymore.' +\n        ' Use canUseDOM from @fluentui/utilities instead.');\n}\n//# sourceMappingURL=setSSR.js.map","import { appendFunction } from './appendFunction';\n/**\n * Extends a component's lifetime methods by appending new functions to the existing lifetime functions.\n */\nexport function extendComponent(parent, methods) {\n    for (var name_1 in methods) {\n        if (methods.hasOwnProperty(name_1)) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            parent[name_1] = appendFunction(parent, parent[name_1], methods[name_1]);\n        }\n    }\n}\n//# sourceMappingURL=extendComponent.js.map","import { elementContainsAttribute } from './dom/elementContainsAttribute';\nimport { elementContains } from './dom/elementContains';\nimport { getParent } from './dom/getParent';\nimport { getWindow } from './dom/getWindow';\nimport { getDocument } from './dom/getDocument';\nvar IS_FOCUSABLE_ATTRIBUTE = 'data-is-focusable';\nvar IS_VISIBLE_ATTRIBUTE = 'data-is-visible';\nvar FOCUSZONE_ID_ATTRIBUTE = 'data-focuszone-id';\nvar FOCUSZONE_SUB_ATTRIBUTE = 'data-is-sub-focuszone';\n/**\n * Gets the first focusable element.\n *\n * @public\n */\nexport function getFirstFocusable(rootElement, currentElement, includeElementsInFocusZones, includeShadowRoots) {\n    return getNextElement(rootElement, currentElement, true /*checkNode*/, false /*suppressParentTraversal*/, false /*suppressChildTraversal*/, includeElementsInFocusZones, undefined, undefined, undefined, includeShadowRoots);\n}\n/**\n * Gets the last focusable element.\n *\n * @public\n */\nexport function getLastFocusable(rootElement, currentElement, includeElementsInFocusZones, includeShadowRoots) {\n    return getPreviousElement(rootElement, currentElement, true /*checkNode*/, false /*suppressParentTraversal*/, true /*traverseChildren*/, includeElementsInFocusZones, undefined, undefined, includeShadowRoots);\n}\n/**\n * Gets the first tabbable element. (The difference between focusable and tabbable is that tabbable elements are\n * focusable elements that also have tabIndex != -1.)\n * @param rootElement - The parent element to search beneath.\n * @param currentElement - The descendant of rootElement to start the search at.  This element is the first one checked,\n * and iteration continues forward.  Typical use passes rootElement.firstChild.\n * @param includeElementsInFocusZones - true if traversal should go into FocusZone descendants.\n * @param checkNode - Include currentElement in search when true. Defaults to true.\n * @public\n */\nexport function getFirstTabbable(rootElement, currentElement, includeElementsInFocusZones, checkNode, includeShadowRoots) {\n    if (checkNode === void 0) { checkNode = true; }\n    return getNextElement(rootElement, currentElement, checkNode, false /*suppressParentTraversal*/, false /*suppressChildTraversal*/, includeElementsInFocusZones, false /*allowFocusRoot*/, true /*tabbable*/, undefined, includeShadowRoots);\n}\n/**\n * Gets the last tabbable element. (The difference between focusable and tabbable is that tabbable elements are\n * focusable elements that also have tabIndex != -1.)\n * @param rootElement - The parent element to search beneath.\n * @param currentElement - The descendant of rootElement to start the search at.  This element is the first one checked,\n * and iteration continues in reverse.  Typical use passes rootElement.lastChild.\n * @param includeElementsInFocusZones - true if traversal should go into FocusZone descendants.\n * @param checkNode - Include currentElement in search when true. Defaults to true.\n * @public\n */\nexport function getLastTabbable(rootElement, currentElement, includeElementsInFocusZones, checkNode, includeShadowRoots) {\n    if (checkNode === void 0) { checkNode = true; }\n    return getPreviousElement(rootElement, currentElement, checkNode, false /*suppressParentTraversal*/, true /*traverseChildren*/, includeElementsInFocusZones, false /*allowFocusRoot*/, true /*tabbable*/, includeShadowRoots);\n}\n/**\n * Attempts to focus the first focusable element that is a child or child's child of the rootElement.\n *\n * @public\n * @param rootElement - Element to start the search for a focusable child.\n * @param bypassHiddenElements - If true, focus will be not be set on hidden elements.\n * @returns True if focus was set, false if it was not.\n */\nexport function focusFirstChild(rootElement, bypassHiddenElements, includeShadowRoots) {\n    var element = getNextElement(rootElement, rootElement, true, false, false, true, undefined, undefined, bypassHiddenElements, includeShadowRoots);\n    if (element) {\n        focusAsync(element);\n        return true;\n    }\n    return false;\n}\n/**\n * Traverse to find the previous element.\n * If tabbable is true, the element must have tabIndex != -1.\n *\n * @public\n */\nexport function getPreviousElement(rootElement, currentElement, checkNode, suppressParentTraversal, traverseChildren, includeElementsInFocusZones, allowFocusRoot, tabbable, includeShadowRoots) {\n    var _a;\n    if (!currentElement || (!allowFocusRoot && currentElement === rootElement)) {\n        return null;\n    }\n    var isCurrentElementVisible = isElementVisible(currentElement);\n    // Check its children.\n    if (traverseChildren &&\n        isCurrentElementVisible &&\n        (includeElementsInFocusZones || !(isElementFocusZone(currentElement) || isElementFocusSubZone(currentElement)))) {\n        var lastElementChild = (currentElement.lastElementChild ||\n            (includeShadowRoots && ((_a = currentElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.lastElementChild)));\n        var childMatch = getPreviousElement(rootElement, lastElementChild, true, true, true, includeElementsInFocusZones, allowFocusRoot, tabbable, includeShadowRoots);\n        if (childMatch) {\n            if ((tabbable && isElementTabbable(childMatch, true, includeShadowRoots)) || !tabbable) {\n                return childMatch;\n            }\n            var childMatchSiblingMatch = getPreviousElement(rootElement, childMatch.previousElementSibling, true, true, true, includeElementsInFocusZones, allowFocusRoot, tabbable, includeShadowRoots);\n            if (childMatchSiblingMatch) {\n                return childMatchSiblingMatch;\n            }\n            var childMatchParent = childMatch.parentElement;\n            // At this point if we have not found any potential matches\n            // start looking at the rest of the subtree under the currentParent.\n            // NOTE: We do not want to recurse here because doing so could\n            // cause elements to get skipped.\n            while (childMatchParent && childMatchParent !== currentElement) {\n                var childMatchParentMatch = getPreviousElement(rootElement, childMatchParent.previousElementSibling, true, true, true, includeElementsInFocusZones, allowFocusRoot, tabbable, includeShadowRoots);\n                if (childMatchParentMatch) {\n                    return childMatchParentMatch;\n                }\n                childMatchParent = childMatchParent.parentElement;\n            }\n        }\n    }\n    // Check the current node, if it's not the first traversal.\n    if (checkNode && isCurrentElementVisible && isElementTabbable(currentElement, tabbable, includeShadowRoots)) {\n        return currentElement;\n    }\n    // Check its previous sibling.\n    var siblingMatch = getPreviousElement(rootElement, currentElement.previousElementSibling, true, true, true, includeElementsInFocusZones, allowFocusRoot, tabbable, includeShadowRoots);\n    if (siblingMatch) {\n        return siblingMatch;\n    }\n    // Check its parent.\n    if (!suppressParentTraversal) {\n        return getPreviousElement(rootElement, currentElement.parentElement, true, false, false, includeElementsInFocusZones, allowFocusRoot, tabbable, includeShadowRoots);\n    }\n    return null;\n}\n/**\n * Traverse to find the next focusable element.\n * If tabbable is true, the element must have tabIndex != -1.\n *\n * @public\n * @param checkNode - Include currentElement in search when true.\n */\nexport function getNextElement(rootElement, currentElement, checkNode, suppressParentTraversal, suppressChildTraversal, includeElementsInFocusZones, allowFocusRoot, tabbable, bypassHiddenElements, includeShadowRoots) {\n    var _a;\n    if (!currentElement || (currentElement === rootElement && suppressChildTraversal && !allowFocusRoot)) {\n        return null;\n    }\n    var checkElementVisibility = bypassHiddenElements ? isElementVisibleAndNotHidden : isElementVisible;\n    var isCurrentElementVisible = checkElementVisibility(currentElement);\n    // Check the current node, if it's not the first traversal.\n    if (checkNode && isCurrentElementVisible && isElementTabbable(currentElement, tabbable, includeShadowRoots)) {\n        return currentElement;\n    }\n    // Check its children.\n    if (!suppressChildTraversal &&\n        isCurrentElementVisible &&\n        (includeElementsInFocusZones || !(isElementFocusZone(currentElement) || isElementFocusSubZone(currentElement)))) {\n        var firstElementchild = (currentElement.firstElementChild ||\n            (includeShadowRoots && ((_a = currentElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.firstElementChild)));\n        var childMatch = getNextElement(rootElement, firstElementchild, true, true, false, includeElementsInFocusZones, allowFocusRoot, tabbable, bypassHiddenElements, includeShadowRoots);\n        if (childMatch) {\n            return childMatch;\n        }\n    }\n    if (currentElement === rootElement) {\n        return null;\n    }\n    // Check its sibling.\n    var siblingMatch = getNextElement(rootElement, currentElement.nextElementSibling, true, true, false, includeElementsInFocusZones, allowFocusRoot, tabbable, bypassHiddenElements, includeShadowRoots);\n    if (siblingMatch) {\n        return siblingMatch;\n    }\n    if (!suppressParentTraversal) {\n        return getNextElement(rootElement, currentElement.parentElement, false, false, true, includeElementsInFocusZones, allowFocusRoot, tabbable, bypassHiddenElements, includeShadowRoots);\n    }\n    return null;\n}\n/**\n * Determines if an element is visible.\n *\n * @public\n */\nexport function isElementVisible(element) {\n    // If the element is not valid, return false.\n    if (!element || !element.getAttribute) {\n        return false;\n    }\n    var visibilityAttribute = element.getAttribute(IS_VISIBLE_ATTRIBUTE);\n    // If the element is explicitly marked with the visibility attribute, return that value as boolean.\n    if (visibilityAttribute !== null && visibilityAttribute !== undefined) {\n        return visibilityAttribute === 'true';\n    }\n    // Fallback to other methods of determining actual visibility.\n    return (element.offsetHeight !== 0 ||\n        element.offsetParent !== null ||\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        element.isVisible === true); // used as a workaround for testing.\n}\n/**\n * Determines if an element is visible and not hidden\n * @param element - Element to check\n * @returns Returns true if the given element is visible and not hidden\n *\n * @public\n */\nexport function isElementVisibleAndNotHidden(element, win) {\n    var theWin = win !== null && win !== void 0 ? win : getWindow();\n    return (!!element &&\n        isElementVisible(element) &&\n        !element.hidden &&\n        theWin.getComputedStyle(element).visibility !== 'hidden');\n}\n/**\n * Determines if an element can receive focus programmatically or via a mouse click.\n * If checkTabIndex is true, additionally checks to ensure the element can be focused with the tab key,\n * meaning tabIndex != -1.\n *\n * @public\n */\nexport function isElementTabbable(element, checkTabIndex, checkShadowRoot) {\n    if (checkShadowRoot === void 0) { checkShadowRoot = true; }\n    // If this element is null or is disabled, it is not considered tabbable.\n    if (!element || element.disabled) {\n        return false;\n    }\n    var tabIndex = 0;\n    var tabIndexAttributeValue = null;\n    if (element && element.getAttribute) {\n        tabIndexAttributeValue = element.getAttribute('tabIndex');\n        if (tabIndexAttributeValue) {\n            tabIndex = parseInt(tabIndexAttributeValue, 10);\n        }\n    }\n    var isFocusableAttribute = element.getAttribute ? element.getAttribute(IS_FOCUSABLE_ATTRIBUTE) : null;\n    var isTabIndexSet = tabIndexAttributeValue !== null && tabIndex >= 0;\n    var delegatesFocus = checkShadowRoot && element.shadowRoot ? !!element.shadowRoot.delegatesFocus : false;\n    var result = !!element &&\n        isFocusableAttribute !== 'false' &&\n        (element.tagName === 'A' ||\n            element.tagName === 'BUTTON' ||\n            element.tagName === 'INPUT' ||\n            element.tagName === 'TEXTAREA' ||\n            element.tagName === 'SELECT' ||\n            isFocusableAttribute === 'true' ||\n            isTabIndexSet ||\n            delegatesFocus);\n    return checkTabIndex ? tabIndex !== -1 && result : result;\n}\n/**\n * Determines if a given element is a focus zone.\n *\n * @public\n */\nexport function isElementFocusZone(element) {\n    return !!(element && element.getAttribute && !!element.getAttribute(FOCUSZONE_ID_ATTRIBUTE));\n}\n/**\n * Determines if a given element is a focus sub zone.\n *\n * @public\n */\nexport function isElementFocusSubZone(element) {\n    return !!(element && element.getAttribute && element.getAttribute(FOCUSZONE_SUB_ATTRIBUTE) === 'true');\n}\n/**\n * Determines if an element, or any of its children, contain focus.\n *\n * @public\n */\nexport function doesElementContainFocus(element) {\n    var doc = getDocument(element);\n    var currentActiveElement = doc && doc.activeElement;\n    if (currentActiveElement && elementContains(element, currentActiveElement)) {\n        return true;\n    }\n    return false;\n}\n/**\n * Determines if an, or any of its ancestors, sepcificies that it doesn't want focus to wrap\n * @param element - element to start searching from\n * @param noWrapDataAttribute - the no wrap data attribute to match (either)\n * @returns true if focus should wrap, false otherwise\n */\nexport function shouldWrapFocus(element, noWrapDataAttribute, doc) {\n    var theDoc = doc !== null && doc !== void 0 ? doc : getDocument();\n    return elementContainsAttribute(element, noWrapDataAttribute, theDoc) === 'true' ? false : true;\n}\nvar animationId = undefined;\n/**\n * Sets focus to an element asynchronously. The focus will be set at the next browser repaint,\n * meaning it won't cause any extra recalculations. If more than one focusAsync is called during one frame,\n * only the latest called focusAsync element will actually be focused\n * @param element - The element to focus\n */\nexport function focusAsync(element) {\n    if (element) {\n        var win = getWindow(element);\n        if (win) {\n            // cancel any previous focus queues\n            if (animationId !== undefined) {\n                win.cancelAnimationFrame(animationId);\n            }\n            // element.focus() is a no-op if the element is no longer in the DOM, meaning this is always safe\n            animationId = win.requestAnimationFrame(function () {\n                element && element.focus();\n                // We are done focusing for this frame, so reset the queued focus element\n                animationId = undefined;\n            });\n        }\n    }\n}\n/**\n * Finds the closest focusable element via an index path from a parent. See\n * `getElementIndexPath` for getting an index path from an element to a child.\n */\nexport function getFocusableByIndexPath(parent, path) {\n    var element = parent;\n    for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {\n        var index = path_1[_i];\n        var nextChild = element.children[Math.min(index, element.children.length - 1)];\n        if (!nextChild) {\n            break;\n        }\n        element = nextChild;\n    }\n    element =\n        isElementTabbable(element) && isElementVisible(element)\n            ? element\n            : getNextElement(parent, element, true) || getPreviousElement(parent, element);\n    return element;\n}\n/**\n * Finds the element index path from a parent element to a child element.\n *\n * If you had this node structure: \"A has children [B, C] and C has child D\",\n * the index path from A to D would be [1, 0], or `parent.chidren[1].children[0]`.\n */\nexport function getElementIndexPath(fromElement, toElement) {\n    var path = [];\n    while (toElement && fromElement && toElement !== fromElement) {\n        var parent_1 = getParent(toElement, true);\n        if (parent_1 === null) {\n            return [];\n        }\n        path.unshift(Array.prototype.indexOf.call(parent_1.children, toElement));\n        toElement = parent_1;\n    }\n    return path;\n}\n//# sourceMappingURL=focus.js.map","import { getWindow } from './dom/getWindow';\nimport { Stylesheet } from '@fluentui/merge-styles';\n// Initialize global window id.\nvar CURRENT_ID_PROPERTY = '__currentId__';\nvar DEFAULT_ID_STRING = 'id__';\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nvar _global = getWindow() || {};\nif (_global[CURRENT_ID_PROPERTY] === undefined) {\n    _global[CURRENT_ID_PROPERTY] = 0;\n}\nvar _initializedStylesheetResets = false;\n/**\n * Generates a unique id in the global scope (this spans across duplicate copies of the same library.)\n *\n * @public\n */\nexport function getId(prefix) {\n    if (!_initializedStylesheetResets) {\n        // Configure ids to reset on stylesheet resets.\n        var stylesheet = Stylesheet.getInstance();\n        if (stylesheet && stylesheet.onReset) {\n            stylesheet.onReset(resetIds);\n        }\n        _initializedStylesheetResets = true;\n    }\n    var index = _global[CURRENT_ID_PROPERTY]++;\n    return (prefix === undefined ? DEFAULT_ID_STRING : prefix) + index;\n}\n/**\n * Resets id counter to an (optional) number.\n *\n * @public\n */\nexport function resetIds(counter) {\n    if (counter === void 0) { counter = 0; }\n    _global[CURRENT_ID_PROPERTY] = counter;\n}\n//# sourceMappingURL=getId.js.map","import { labelProperties, audioProperties, videoProperties, olProperties, liProperties, anchorProperties, buttonProperties, inputProperties, textAreaProperties, selectProperties, optionProperties, tableProperties, trProperties, thProperties, tdProperties, colGroupProperties, colProperties, formProperties, iframeProperties, imgProperties, htmlElementProperties, getNativeProps, } from './properties';\nvar nativeElementMap = {\n    label: labelProperties,\n    audio: audioProperties,\n    video: videoProperties,\n    ol: olProperties,\n    li: liProperties,\n    a: anchorProperties,\n    button: buttonProperties,\n    input: inputProperties,\n    textarea: textAreaProperties,\n    select: selectProperties,\n    option: optionProperties,\n    table: tableProperties,\n    tr: trProperties,\n    th: thProperties,\n    td: tdProperties,\n    colGroup: colGroupProperties,\n    col: colProperties,\n    form: formProperties,\n    iframe: iframeProperties,\n    img: imgProperties,\n};\n/**\n * Given an element tagname and user props, filters the props to only allowed props for the given\n * element type.\n * @param tagName - Tag name (e.g. \"div\")\n * @param props - Props object\n * @param excludedPropNames - List of props to disallow\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getNativeElementProps(tagName, props, excludedPropNames) {\n    var allowedPropNames = (tagName && nativeElementMap[tagName]) || htmlElementProperties;\n    return getNativeProps(props, allowedPropNames, excludedPropNames);\n}\n//# sourceMappingURL=getNativeElementProps.js.map","import { __assign } from \"tslib\";\n/**\n * Function to apply default values to a component props object. This function is intended for function components,\n * to maintain parity with the `defaultProps` feature of class components. It accounts for properties that are\n * specified, but undefined.\n * @param defaultProps- An object with default values for various properties\n * @param propsWithoutDefaults- The props object passed into the component\n */\nexport function getPropsWithDefaults(defaultProps, propsWithoutDefaults) {\n    var props = __assign({}, propsWithoutDefaults);\n    for (var _i = 0, _a = Object.keys(defaultProps); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (props[key] === undefined) {\n            props[key] = defaultProps[key];\n        }\n    }\n    return props;\n}\n//# sourceMappingURL=getPropsWithDefaults.js.map","var REACT_LIFECYCLE_EXCLUSIONS = [\n    'setState',\n    'render',\n    'componentWillMount',\n    'UNSAFE_componentWillMount',\n    'componentDidMount',\n    'componentWillReceiveProps',\n    'UNSAFE_componentWillReceiveProps',\n    'shouldComponentUpdate',\n    'componentWillUpdate',\n    'getSnapshotBeforeUpdate',\n    'UNSAFE_componentWillUpdate',\n    'componentDidUpdate',\n    'componentWillUnmount',\n];\n/**\n * Allows you to hoist methods, except those in an exclusion set from a source object into a destination object.\n *\n * @public\n * @param destination - The instance of the object to hoist the methods onto.\n * @param source - The instance of the object where the methods are hoisted from.\n * @param exclusions - (Optional) What methods to exclude from being hoisted.\n * @returns An array of names of methods that were hoisted.\n */\nexport function hoistMethods(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ndestination, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nsource, exclusions) {\n    if (exclusions === void 0) { exclusions = REACT_LIFECYCLE_EXCLUSIONS; }\n    var hoisted = [];\n    var _loop_1 = function (methodName) {\n        if (typeof source[methodName] === 'function' &&\n            destination[methodName] === undefined &&\n            (!exclusions || exclusions.indexOf(methodName) === -1)) {\n            hoisted.push(methodName);\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            destination[methodName] = function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                source[methodName].apply(source, args);\n            };\n        }\n    };\n    for (var methodName in source) {\n        _loop_1(methodName);\n    }\n    return hoisted;\n}\n/**\n * Provides a method for convenience to unhoist hoisted methods.\n *\n * @public\n * @param source - The source object upon which methods were hoisted.\n * @param methodNames - An array of method names to unhoist.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function unhoistMethods(source, methodNames) {\n    methodNames.forEach(function (methodName) { return delete source[methodName]; });\n}\n//# sourceMappingURL=hoist.js.map","/**\n * Allows you to hoist static functions in components.\n * Created for the purpose of fixing broken static functions in classes\n * that utilize decorators.\n *\n * @public\n * @param source - The object where the methods are hoisted from.\n * @param dest - The object to hoist the methods onto.\n * @returns The dest object with methods added\n */\nexport function hoistStatics(source, dest) {\n    for (var name_1 in source) {\n        if (source.hasOwnProperty(name_1)) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            dest[name_1] = source[name_1];\n        }\n    }\n    return dest;\n}\n//# sourceMappingURL=hoistStatics.js.map","import { getWindow } from './dom/getWindow';\nexport var isIE11 = function () {\n    var _a;\n    var win = getWindow();\n    if (!((_a = win === null || win === void 0 ? void 0 : win.navigator) === null || _a === void 0 ? void 0 : _a.userAgent)) {\n        return false;\n    }\n    return win.navigator.userAgent.indexOf('rv:11.0') > -1;\n};\n//# sourceMappingURL=ie11Detector.js.map","import { extendComponent } from './extendComponent';\n/**\n * Helper to manage componentRef resolution. Internally appends logic to\n * lifetime methods to resolve componentRef to the passed in object.\n *\n * Usage: call initializeComponentRef(this) in the constructor,\n */\nexport function initializeComponentRef(obj) {\n    extendComponent(obj, {\n        componentDidMount: _onMount,\n        componentDidUpdate: _onUpdate,\n        componentWillUnmount: _onUnmount,\n    });\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _onMount() {\n    _setComponentRef(this.props.componentRef, this);\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _onUpdate(prevProps) {\n    if (prevProps.componentRef !== this.props.componentRef) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        _setComponentRef(prevProps.componentRef, null);\n        _setComponentRef(this.props.componentRef, this);\n    }\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _onUnmount() {\n    _setComponentRef(this.props.componentRef, null);\n}\nfunction _setComponentRef(componentRef, value) {\n    if (componentRef) {\n        if (typeof componentRef === 'object') {\n            componentRef.current = value;\n        }\n        else if (typeof componentRef === 'function') {\n            componentRef(value);\n        }\n    }\n}\n//# sourceMappingURL=initializeComponentRef.js.map","import { getWindow } from './dom/getWindow';\nimport { isDirectionalKeyCode } from './keyboard';\nimport { setFocusVisibility } from './setFocusVisibility';\n/**\n * Initializes the logic which:\n *\n * 1. Subscribes keydown and mousedown events. (It will only do it once per window,\n *    so it's safe to call this method multiple times.)\n * 2. When the user presses directional keyboard keys, adds the 'ms-Fabric--isFocusVisible' classname\n *    to the document body, removes the 'ms-Fabric-isFocusHidden' classname.\n * 3. When the user clicks a mouse button, adds the 'ms-Fabric-isFocusHidden' classname to the\n *    document body, removes the 'ms-Fabric--isFocusVisible' classname.\n *\n * This logic allows components on the page to conditionally render focus treatments based on\n * the existence of global classnames, which simplifies logic overall.\n *\n * @param window - the window used to add the event listeners\n * @deprecated Use useFocusRects hook or FocusRects component instead.\n */\nexport function initializeFocusRects(window) {\n    var _a;\n    var win = (window || getWindow());\n    if (!win || ((_a = win.FabricConfig) === null || _a === void 0 ? void 0 : _a.disableFocusRects) === true) {\n        return;\n    }\n    if (!win.__hasInitializeFocusRects__) {\n        win.__hasInitializeFocusRects__ = true;\n        win.addEventListener('mousedown', _onMouseDown, true);\n        win.addEventListener('pointerdown', _onPointerDown, true);\n        win.addEventListener('keydown', _onKeyDown, true);\n    }\n}\nfunction _onMouseDown(ev) {\n    setFocusVisibility(false, ev.target);\n}\nfunction _onPointerDown(ev) {\n    if (ev.pointerType !== 'mouse') {\n        setFocusVisibility(false, ev.target);\n    }\n}\nfunction _onKeyDown(ev) {\n    // eslint-disable-next-line deprecation/deprecation\n    isDirectionalKeyCode(ev.which) && setFocusVisibility(true, ev.target);\n}\n//# sourceMappingURL=initializeFocusRects.js.map","/**\n * Regular expressions matching characters to ignore when calculating the initials.\n */\n/**\n * Regular expression matching characters within various types of enclosures, including the enclosures themselves\n *  so for example, (xyz) [xyz] {xyz} <xyz> all would be ignored\n */\nvar UNWANTED_ENCLOSURES_REGEX = /[\\(\\[\\{\\<][^\\)\\]\\}\\>]*[\\)\\]\\}\\>]/g;\n/**\n * Regular expression matching special ASCII characters except space, plus some unicode special characters.\n * Applies after unwanted enclosures have been removed\n */\nvar UNWANTED_CHARS_REGEX = /[\\0-\\u001F\\!-/:-@\\[-`\\{-\\u00BF\\u0250-\\u036F\\uD800-\\uFFFF]/g;\n/**\n * Regular expression matching phone numbers. Applied after chars matching UNWANTED_CHARS_REGEX have been removed\n * and number has been trimmed for whitespaces\n */\nvar PHONENUMBER_REGEX = /^\\d+[\\d\\s]*(:?ext|x|)\\s*\\d+$/i;\n/** Regular expression matching one or more spaces. */\nvar MULTIPLE_WHITESPACES_REGEX = /\\s+/g;\n/**\n * Regular expression matching languages for which we currently don't support initials.\n * Arabic:   Arabic, Arabic Supplement, Arabic Extended-A.\n * Korean:   Hangul Jamo, Hangul Compatibility Jamo, Hangul Jamo Extended-A, Hangul Syllables, Hangul Jamo Extended-B.\n * Japanese: Hiragana, Katakana.\n * CJK:      CJK Unified Ideographs Extension A, CJK Unified Ideographs, CJK Compatibility Ideographs,\n *             CJK Unified Ideographs Extension B\n */\nvar UNSUPPORTED_TEXT_REGEX = \n// eslint-disable-next-line @fluentui/max-len\n/[\\u0600-\\u06FF\\u0750-\\u077F\\u08A0-\\u08FF\\u1100-\\u11FF\\u3130-\\u318F\\uA960-\\uA97F\\uAC00-\\uD7AF\\uD7B0-\\uD7FF\\u3040-\\u309F\\u30A0-\\u30FF\\u3400-\\u4DBF\\u4E00-\\u9FFF\\uF900-\\uFAFF]|[\\uD840-\\uD869][\\uDC00-\\uDED6]/;\nfunction getInitialsLatin(displayName, isRtl) {\n    var initials = '';\n    var splits = displayName.split(' ');\n    if (splits.length === 2) {\n        initials += splits[0].charAt(0).toUpperCase();\n        initials += splits[1].charAt(0).toUpperCase();\n    }\n    else if (splits.length === 3) {\n        initials += splits[0].charAt(0).toUpperCase();\n        initials += splits[2].charAt(0).toUpperCase();\n    }\n    else if (splits.length !== 0) {\n        initials += splits[0].charAt(0).toUpperCase();\n    }\n    if (isRtl && initials.length > 1) {\n        return initials.charAt(1) + initials.charAt(0);\n    }\n    return initials;\n}\nfunction cleanupDisplayName(displayName) {\n    displayName = displayName.replace(UNWANTED_ENCLOSURES_REGEX, '');\n    displayName = displayName.replace(UNWANTED_CHARS_REGEX, '');\n    displayName = displayName.replace(MULTIPLE_WHITESPACES_REGEX, ' ');\n    displayName = displayName.trim();\n    return displayName;\n}\n/**\n * Get (up to 2 characters) initials based on display name of the persona.\n *\n * @public\n */\nexport function getInitials(displayName, isRtl, allowPhoneInitials) {\n    if (!displayName) {\n        return '';\n    }\n    displayName = cleanupDisplayName(displayName);\n    // For names containing CJK characters, and phone numbers, we don't display initials\n    if (UNSUPPORTED_TEXT_REGEX.test(displayName) || (!allowPhoneInitials && PHONENUMBER_REGEX.test(displayName))) {\n        return '';\n    }\n    return getInitialsLatin(displayName, isRtl);\n}\n//# sourceMappingURL=initials.js.map","var _a;\nimport { KeyCodes } from './KeyCodes';\nvar DirectionalKeyCodes = (_a = {},\n    _a[KeyCodes.up] = 1,\n    _a[KeyCodes.down] = 1,\n    _a[KeyCodes.left] = 1,\n    _a[KeyCodes.right] = 1,\n    _a[KeyCodes.home] = 1,\n    _a[KeyCodes.end] = 1,\n    _a[KeyCodes.tab] = 1,\n    _a[KeyCodes.pageUp] = 1,\n    _a[KeyCodes.pageDown] = 1,\n    _a);\n/**\n * Returns true if the keycode is a directional keyboard key.\n */\nexport function isDirectionalKeyCode(which) {\n    return !!DirectionalKeyCodes[which];\n}\n/**\n * Adds a keycode to the list of keys that, when pressed, should cause the focus outlines to be visible.\n * This can be used to add global shortcut keys that directionally move from section to section within\n * an app or between focus trap zones.\n */\nexport function addDirectionalKeyCode(which) {\n    DirectionalKeyCodes[which] = 1;\n}\n/**\n * Removes a keycode to the list of keys that, when pressed, should cause the focus outlines to be visible.\n * This can be used to remove global shortcut keys that directionally move from section to section within\n * an app or between focus trap zones.\n */\nexport function removeDirectionalKeyCode(which) {\n    delete DirectionalKeyCodes[which];\n}\n//# sourceMappingURL=keyboard.js.map","import { getDocument } from './dom/getDocument';\nimport * as localStorage from './localStorage';\nimport * as sessionStorage from './sessionStorage';\n// Default to undefined so that we initialize on first read.\nvar _language;\nvar STORAGE_KEY = 'language';\n/**\n * Gets the language set for the page.\n * @param persistenceType - Where to persist the value. Default is `sessionStorage` if available.\n */\nexport function getLanguage(persistenceType) {\n    if (persistenceType === void 0) { persistenceType = 'sessionStorage'; }\n    if (_language === undefined) {\n        var doc = getDocument();\n        var savedLanguage = persistenceType === 'localStorage'\n            ? localStorage.getItem(STORAGE_KEY)\n            : persistenceType === 'sessionStorage'\n                ? sessionStorage.getItem(STORAGE_KEY)\n                : undefined;\n        if (savedLanguage) {\n            _language = savedLanguage;\n        }\n        if (_language === undefined && doc) {\n            _language = doc.documentElement.getAttribute('lang');\n        }\n        if (_language === undefined) {\n            _language = 'en';\n        }\n    }\n    return _language;\n}\nexport function setLanguage(language, persistenceParam) {\n    var doc = getDocument();\n    if (doc) {\n        doc.documentElement.setAttribute('lang', language);\n    }\n    var persistenceType = persistenceParam === true ? 'none' : !persistenceParam ? 'sessionStorage' : persistenceParam;\n    if (persistenceType === 'localStorage') {\n        localStorage.setItem(STORAGE_KEY, language);\n    }\n    else if (persistenceType === 'sessionStorage') {\n        sessionStorage.setItem(STORAGE_KEY, language);\n    }\n    _language = language;\n}\n//# sourceMappingURL=language.js.map","import { getWindow } from './dom/getWindow';\n/**\n * Fetches an item from local storage without throwing an exception\n * @param key The key of the item to fetch from local storage\n */\nexport function getItem(key) {\n    var result = null;\n    try {\n        var win = getWindow();\n        result = win ? win.localStorage.getItem(key) : null;\n    }\n    catch (e) {\n        /* Eat the exception */\n    }\n    return result;\n}\n/**\n * Inserts an item into local storage without throwing an exception\n * @param key The key of the item to add to local storage\n * @param data The data to put into local storage\n */\nexport function setItem(key, data) {\n    try {\n        var win = getWindow();\n        win && win.localStorage.setItem(key, data);\n    }\n    catch (e) {\n        /* Eat the exception */\n    }\n}\n//# sourceMappingURL=localStorage.js.map","/**\n * Determines the distance between two points.\n *\n * @public\n */\n/* eslint-disable deprecation/deprecation */\nexport function getDistanceBetweenPoints(point1, point2) {\n    var left1 = point1.left || point1.x || 0;\n    var top1 = point1.top || point1.y || 0;\n    var left2 = point2.left || point2.x || 0;\n    var top2 = point2.top || point2.y || 0;\n    /* eslint-enable deprecation/deprecation */\n    var distance = Math.sqrt(Math.pow(left1 - left2, 2) + Math.pow(top1 - top2, 2));\n    return distance;\n}\n/**\n * Produces a proportionally-scaled version of an input content size when fit to a bounding size.\n * Given a `contentSize` and a `boundsSize`, this function scales `contentSize` proportionally\n * using either `contain` or `cover` fit behaviors.\n * Use this function to pre-calculate the layout for the CSS `object-fit` and `background-fit` behaviors.\n * With `contain`, the output size must be the largest it can be while completely within the `boundsSize`.\n * With `cover`, the output size must be the smallest it can be while completely around the `boundsSize`.\n * By default, there is a `maxScale` value of 1, which prevents the `contentSize` from being scaled larger.\n *\n * @param options - the options for the bounds fit operation\n */\nexport function fitContentToBounds(options) {\n    var contentSize = options.contentSize, boundsSize = options.boundsSize, _a = options.mode, mode = _a === void 0 ? 'contain' : _a, _b = options.maxScale, maxScale = _b === void 0 ? 1 : _b;\n    var contentAspectRatio = contentSize.width / contentSize.height;\n    var boundsAspectRatio = boundsSize.width / boundsSize.height;\n    var scale;\n    if (mode === 'contain' ? contentAspectRatio > boundsAspectRatio : contentAspectRatio < boundsAspectRatio) {\n        scale = boundsSize.width / contentSize.width;\n    }\n    else {\n        scale = boundsSize.height / contentSize.height;\n    }\n    var finalScale = Math.min(maxScale, scale);\n    return {\n        width: contentSize.width * finalScale,\n        height: contentSize.height * finalScale,\n    };\n}\n/**\n * Calculates a number's precision based on the number of trailing\n * zeros if the number does not have a decimal indicated by a negative\n * precision. Otherwise, it calculates the number of digits after\n * the decimal point indicated by a positive precision.\n * @param value - the value to determine the precision of\n */\nexport function calculatePrecision(value) {\n    /**\n     * Group 1:\n     * [1-9]([0]+$) matches trailing zeros\n     * Group 2:\n     * \\.([0-9]*) matches all digits after a decimal point.\n     */\n    var groups = /[1-9]([0]+$)|\\.([0-9]*)/.exec(String(value));\n    if (!groups) {\n        return 0;\n    }\n    if (groups[1]) {\n        return -groups[1].length;\n    }\n    if (groups[2]) {\n        return groups[2].length;\n    }\n    return 0;\n}\n/**\n * Rounds a number to a certain level of precision. Accepts negative precision.\n * @param value - The value that is being rounded.\n * @param precision - The number of decimal places to round the number to\n */\nexport function precisionRound(value, precision, base) {\n    if (base === void 0) { base = 10; }\n    var exp = Math.pow(base, precision);\n    return Math.round(value * exp) / exp;\n}\n//# sourceMappingURL=math.js.map","import { Stylesheet } from '@fluentui/merge-styles';\nvar _initializedStylesheetResets = false;\nvar _resetCounter = 0;\nvar _emptyObject = { empty: true };\nvar _dictionary = {};\nvar _weakMap = typeof WeakMap === 'undefined' ? null : WeakMap;\n/**\n *  Test utility for providing a custom weakmap.\n *\n * @internal\n * */\nexport function setMemoizeWeakMap(weakMap) {\n    _weakMap = weakMap;\n}\n/**\n * Reset memoizations.\n */\nexport function resetMemoizations() {\n    _resetCounter++;\n}\n/**\n * Memoize decorator to be used on class methods. WARNING: the `this` reference\n * will be inaccessible within a memoized method, given that a cached method's `this`\n * would not be instance-specific.\n *\n * @public\n */\nexport function memoize(_target, _key, descriptor) {\n    // We bind to \"null\" to prevent people from inadvertently pulling values from \"this\",\n    // rather than passing them in as input values which can be memoized.\n    var fn = memoizeFunction(descriptor.value && descriptor.value.bind(null));\n    return {\n        configurable: true,\n        get: function () {\n            return fn;\n        },\n    };\n}\n/**\n * Memoizes a function; when you pass in the same parameters multiple times, it returns a cached result.\n * Be careful when passing in objects, you need to pass in the same INSTANCE for caching to work. Otherwise\n * it will grow the cache unnecessarily. Also avoid using default values that evaluate functions; passing in\n * undefined for a value and relying on a default function will execute it the first time, but will not\n * re-evaluate subsequent times which may have been unexpected.\n *\n * By default, the cache will reset after 100 permutations, to avoid abuse cases where the function is\n * unintendedly called with unique objects. Without a reset, the cache could grow infinitely, so we safeguard\n * by resetting. To override this behavior, pass a value of 0 to the maxCacheSize parameter.\n *\n * @public\n * @param cb - The function to memoize.\n * @param maxCacheSize - Max results to cache. If the cache exceeds this value, it will reset on the next call.\n * @param ignoreNullOrUndefinedResult - Flag to decide whether to cache callback result if it is undefined/null.\n * If the flag is set to true, the callback result is recomputed every time till the callback result is\n * not undefined/null for the first time, and then the non-undefined/null version gets cached.\n * @returns A memoized version of the function.\n */\nexport function memoizeFunction(cb, maxCacheSize, ignoreNullOrUndefinedResult) {\n    if (maxCacheSize === void 0) { maxCacheSize = 100; }\n    if (ignoreNullOrUndefinedResult === void 0) { ignoreNullOrUndefinedResult = false; }\n    // Avoid breaking scenarios which don't have weak map.\n    if (!_weakMap) {\n        return cb;\n    }\n    if (!_initializedStylesheetResets) {\n        var stylesheet = Stylesheet.getInstance();\n        if (stylesheet && stylesheet.onReset) {\n            Stylesheet.getInstance().onReset(resetMemoizations);\n        }\n        _initializedStylesheetResets = true;\n    }\n    var rootNode;\n    var cacheSize = 0;\n    var localResetCounter = _resetCounter;\n    return function memoizedFunction() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var currentNode = rootNode;\n        if (rootNode === undefined ||\n            localResetCounter !== _resetCounter ||\n            (maxCacheSize > 0 && cacheSize > maxCacheSize)) {\n            rootNode = _createNode();\n            cacheSize = 0;\n            localResetCounter = _resetCounter;\n        }\n        currentNode = rootNode;\n        // Traverse the tree until we find the match.\n        for (var i = 0; i < args.length; i++) {\n            var arg = _normalizeArg(args[i]);\n            if (!currentNode.map.has(arg)) {\n                currentNode.map.set(arg, _createNode());\n            }\n            currentNode = currentNode.map.get(arg);\n        }\n        if (!currentNode.hasOwnProperty('value')) {\n            currentNode.value = cb.apply(void 0, args);\n            cacheSize++;\n        }\n        if (ignoreNullOrUndefinedResult && (currentNode.value === null || currentNode.value === undefined)) {\n            currentNode.value = cb.apply(void 0, args);\n        }\n        return currentNode.value;\n    };\n}\n/**\n * Creates a memoizer for a single-value function, backed by a WeakMap.\n * With a WeakMap, the memoized values are only kept as long as the source objects,\n * ensuring that there is no memory leak.\n *\n * This function assumes that the input values passed to the wrapped function will be\n * `function` or `object` types. To memoize functions which accept other inputs, use\n * `memoizeFunction`, which memoizes against arbitrary inputs using a lookup cache.\n *\n * @public\n */\nexport function createMemoizer(getValue) {\n    if (!_weakMap) {\n        // Without a `WeakMap` implementation, memoization is not possible.\n        return getValue;\n    }\n    var cache = new _weakMap();\n    function memoizedGetValue(input) {\n        if (!input || (typeof input !== 'function' && typeof input !== 'object')) {\n            // A WeakMap can only be used to test against reference values, i.e. 'function' and 'object'.\n            // All other inputs cannot be memoized against in this manner.\n            return getValue(input);\n        }\n        if (cache.has(input)) {\n            return cache.get(input);\n        }\n        var value = getValue(input);\n        cache.set(input, value);\n        return value;\n    }\n    return memoizedGetValue;\n}\nfunction _normalizeArg(val) {\n    if (!val) {\n        return _emptyObject;\n    }\n    else if (typeof val === 'object' || typeof val === 'function') {\n        return val;\n    }\n    else if (!_dictionary[val]) {\n        _dictionary[val] = { val: val };\n    }\n    return _dictionary[val];\n}\nfunction _createNode() {\n    return {\n        map: _weakMap ? new _weakMap() : null,\n    };\n}\n//# sourceMappingURL=memoize.js.map","/**\n * Simple deep merge function. Takes all arguments and returns a deep copy of the objects merged\n * together in the order provided. If an object creates a circular reference, it will assign the\n * original reference.\n */\nexport function merge(target) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {\n        var arg = args_1[_a];\n        _merge(target || {}, arg);\n    }\n    return target;\n}\n/**\n * The _merge helper iterates through all props on source and assigns them to target.\n * When the value is an object, we will create a deep clone of the object. However if\n * there is a circular reference, the value will not be deep cloned and will persist\n * the reference.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _merge(target, source, circularReferences) {\n    if (circularReferences === void 0) { circularReferences = []; }\n    circularReferences.push(source);\n    for (var name_1 in source) {\n        if (source.hasOwnProperty(name_1)) {\n            if (name_1 !== '__proto__' && name_1 !== 'constructor' && name_1 !== 'prototype') {\n                var value = source[name_1];\n                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n                    var isCircularReference = circularReferences.indexOf(value) > -1;\n                    target[name_1] = (isCircularReference ? value : _merge(target[name_1] || {}, value, circularReferences));\n                }\n                else {\n                    target[name_1] = value;\n                }\n            }\n        }\n    }\n    circularReferences.pop();\n    return target;\n}\n//# sourceMappingURL=merge.js.map","/**\n * Returns true if and only if the user is on a iOS device.\n * Used to determine whether iOS-specific behavior should be applied.\n */\nexport var isIOS = function () {\n    // eslint-disable-next-line no-restricted-globals\n    if (!window || !window.navigator || !window.navigator.userAgent) {\n        return false;\n    }\n    // eslint-disable-next-line no-restricted-globals\n    return /iPad|iPhone|iPod/i.test(window.navigator.userAgent);\n};\n//# sourceMappingURL=mobileDetector.js.map","/**\n * The helper functions here will make the target element as modal to screen readers, by placing aria-hidden on elements\n * that are siblings to the target element and the target element's ancestors (because aria-hidden gets inherited).\n * That way, all other elements on the page are hidden to the screen reader.\n */\nimport { getDocument } from './dom/getDocument';\n/** Tag names to ignore when modalizing */\nvar tagsToIgnore = ['TEMPLATE', 'STYLE', 'SCRIPT'];\n/**\n * Call this on a target element to make it modal to screen readers.\n * Returns a function that undoes the changes it made.\n */\nexport function modalize(target) {\n    var targetDocument = getDocument(target);\n    if (!targetDocument) {\n        // can't do this in SSR\n        return function () { return undefined; };\n    }\n    var affectedNodes = [];\n    // start at target, then recurse and do the same for parent, until we reach <body>\n    while (target !== targetDocument.body && target.parentElement) {\n        // grab all siblings of current element\n        for (var _i = 0, _a = target.parentElement.children; _i < _a.length; _i++) {\n            var sibling = _a[_i];\n            // but ignore elements that are already aria-hidden\n            var ariaHidden = sibling.getAttribute('aria-hidden');\n            if (sibling !== target && (ariaHidden === null || ariaHidden === void 0 ? void 0 : ariaHidden.toLowerCase()) !== 'true' && tagsToIgnore.indexOf(sibling.tagName) === -1) {\n                affectedNodes.push([sibling, ariaHidden]);\n            }\n        }\n        target = target.parentElement;\n    }\n    // take all those elements and set aria-hidden=true on them\n    affectedNodes.forEach(function (_a) {\n        var node = _a[0];\n        node.setAttribute('aria-hidden', 'true');\n    });\n    return function () {\n        unmodalize(affectedNodes);\n        affectedNodes = []; // dispose\n    };\n}\n/**\n * Undoes the changes that modalize() did.\n */\nfunction unmodalize(affectedNodes) {\n    affectedNodes.forEach(function (_a) {\n        var node = _a[0], originalValue = _a[1];\n        // Restore the original value (false or unset)\n        if (originalValue) {\n            node.setAttribute('aria-hidden', originalValue);\n        }\n        else {\n            node.removeAttribute('aria-hidden');\n        }\n    });\n}\n//# sourceMappingURL=modalize.js.map","/**\n * Compares a to b and b to a.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function shallowCompare(a, b) {\n    if (!a || !b) {\n        // only return true if both a and b are falsy\n        return !a && !b;\n    }\n    for (var propName in a) {\n        if (a.hasOwnProperty(propName)) {\n            if (!b.hasOwnProperty(propName) || b[propName] !== a[propName]) {\n                return false;\n            }\n        }\n    }\n    for (var propName in b) {\n        if (b.hasOwnProperty(propName)) {\n            if (!a.hasOwnProperty(propName)) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\n/**\n * Makes a resulting merge of a bunch of objects. Pass in the target object followed by 1 or more\n * objects as arguments and they will be merged sequentially into the target. Note that this will\n * shallow merge; it will not create new cloned values for target members.\n *\n * @public\n * @param target - Target object to merge following object arguments into.\n * @param args - One or more objects that will be mixed into the target in the order they are provided.\n * @returns Resulting merged target.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function assign(target) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return filteredAssign.apply(this, [null, target].concat(args));\n}\n/**\n * Makes a resulting merge of a bunch of objects, but allows a filter function to be passed in to filter\n * the resulting merges. This allows for scenarios where you want to merge \"everything except that one thing\"\n * or \"properties that start with data-\". Note that this will shallow merge; it will not create new cloned\n * values for target members.\n *\n * @public\n * @param isAllowed - Callback to determine if the given propName is allowed in the result.\n * @param target - Target object to merge following object arguments into.\n * @param args - One or more objects that will be mixed into the target in the order they are provided.\n * @returns Resulting merged target.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function filteredAssign(isAllowed, target) {\n    var args = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n    }\n    target = target || {};\n    for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {\n        var sourceObject = args_1[_a];\n        if (sourceObject) {\n            for (var propName in sourceObject) {\n                if (sourceObject.hasOwnProperty(propName) && (!isAllowed || isAllowed(propName))) {\n                    target[propName] = sourceObject[propName];\n                }\n            }\n        }\n    }\n    return target;\n}\n/**\n * Takes an enum and iterates over each value of the enum (as a string), running the callback on each,\n * returning a mapped array.\n * @param theEnum - Enum to iterate over\n * @param callback - The first parameter the name of the entry, and the second parameter is the value\n * of that entry, which is the value you'd normally use when using the enum (usually a number).\n */\nexport function mapEnumByName(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntheEnum, callback) {\n    // map<any> to satisfy compiler since it doesn't realize we strip out undefineds in the .filter() call\n    return Object.keys(theEnum)\n        .map(function (p) {\n        // map on each property name as a string\n        if (String(Number(p)) !== p) {\n            // if the property is not just a number (because enums in TypeScript will map both ways)\n            return callback(p, theEnum[p]);\n        }\n        return undefined;\n    })\n        .filter(function (v) { return !!v; }); // only return elements with values\n}\n/**\n * Get all values in an object dictionary\n *\n * @param obj - The dictionary to get values for\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function values(obj) {\n    return Object.keys(obj).reduce(function (arr, key) {\n        arr.push(obj[key]);\n        return arr;\n    }, []);\n}\n/**\n * Tiny helper to do the minimal amount of work in duplicating an object but omitting some\n * props. This ends up faster than using object ...rest or reduce to filter.\n *\n * This behaves very much like filteredAssign, but does not merge many objects together,\n * uses an exclusion object map, and avoids spreads all for optimal performance.\n *\n * See perf test for background:\n * https://jsperf.com/omit-vs-rest-vs-reduce/1\n *\n * @param obj - The object to clone\n * @param exclusions - The array of keys to exclude\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function omit(obj, exclusions) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var result = {};\n    for (var key in obj) {\n        if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=object.js.map","import { getWindow } from './dom/getWindow';\nvar isMacResult;\n/**\n * Returns true if the user is on a Mac. Caches the result value.\n * @param reset - Reset the cached result value (mainly for testing).\n */\nexport function isMac(reset) {\n    var _a;\n    if (typeof isMacResult === 'undefined' || reset) {\n        var win = getWindow();\n        // In certain SSR frameworks, `window` will be defined even on the server but `navigator` will be undefined\n        var userAgent = (_a = win === null || win === void 0 ? void 0 : win.navigator) === null || _a === void 0 ? void 0 : _a.userAgent;\n        isMacResult = !!userAgent && userAgent.indexOf('Macintosh') !== -1;\n    }\n    return !!isMacResult;\n}\n//# sourceMappingURL=osDetector.js.map","/**\n * Detects whether an element's content has horizontal overflow\n *\n * @public\n * @param element - Element to check for overflow\n * @returns True if element's content overflows\n */\nexport function hasHorizontalOverflow(element) {\n    return element.clientWidth < element.scrollWidth;\n}\n/**\n * Detects whether an element's content has vertical overflow\n *\n * @public\n * @param element - Element to check for overflow\n * @returns True if element's content overflows\n */\nexport function hasVerticalOverflow(element) {\n    return element.clientHeight < element.scrollHeight;\n}\n/**\n * Detects whether an element's content has overflow in any direction\n *\n * @public\n * @param element - Element to check for overflow\n * @returns True if element's content overflows\n */\nexport function hasOverflow(element) {\n    return hasHorizontalOverflow(element) || hasVerticalOverflow(element);\n}\n//# sourceMappingURL=overflow.js.map","var toObjectMap = function () {\n    var items = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        items[_i] = arguments[_i];\n    }\n    var result = {};\n    for (var _a = 0, items_1 = items; _a < items_1.length; _a++) {\n        var item = items_1[_a];\n        var keys = Array.isArray(item) ? item : Object.keys(item);\n        for (var _b = 0, keys_1 = keys; _b < keys_1.length; _b++) {\n            var key = keys_1[_b];\n            result[key] = 1;\n        }\n    }\n    return result;\n};\n/**\n * An array of events that are allowed on every html element type.\n *\n * @public\n */\nexport var baseElementEvents = toObjectMap([\n    'onCopy',\n    'onCut',\n    'onPaste',\n    'onCompositionEnd',\n    'onCompositionStart',\n    'onCompositionUpdate',\n    'onFocus',\n    'onFocusCapture',\n    'onBlur',\n    'onBlurCapture',\n    'onChange',\n    'onInput',\n    'onSubmit',\n    'onLoad',\n    'onError',\n    'onKeyDown',\n    'onKeyDownCapture',\n    'onKeyPress',\n    'onKeyUp',\n    'onAbort',\n    'onCanPlay',\n    'onCanPlayThrough',\n    'onDurationChange',\n    'onEmptied',\n    'onEncrypted',\n    'onEnded',\n    'onLoadedData',\n    'onLoadedMetadata',\n    'onLoadStart',\n    'onPause',\n    'onPlay',\n    'onPlaying',\n    'onProgress',\n    'onRateChange',\n    'onSeeked',\n    'onSeeking',\n    'onStalled',\n    'onSuspend',\n    'onTimeUpdate',\n    'onVolumeChange',\n    'onWaiting',\n    'onClick',\n    'onClickCapture',\n    'onContextMenu',\n    'onDoubleClick',\n    'onDrag',\n    'onDragEnd',\n    'onDragEnter',\n    'onDragExit',\n    'onDragLeave',\n    'onDragOver',\n    'onDragStart',\n    'onDrop',\n    'onMouseDown',\n    'onMouseDownCapture',\n    'onMouseEnter',\n    'onMouseLeave',\n    'onMouseMove',\n    'onMouseOut',\n    'onMouseOver',\n    'onMouseUp',\n    'onMouseUpCapture',\n    'onSelect',\n    'onTouchCancel',\n    'onTouchEnd',\n    'onTouchMove',\n    'onTouchStart',\n    'onScroll',\n    'onWheel',\n    'onPointerCancel',\n    'onPointerDown',\n    'onPointerEnter',\n    'onPointerLeave',\n    'onPointerMove',\n    'onPointerOut',\n    'onPointerOver',\n    'onPointerUp',\n    'onGotPointerCapture',\n    'onLostPointerCapture',\n]);\n/**\n * An array of element attributes which are allowed on every html element type.\n *\n * @public\n */\nexport var baseElementProperties = toObjectMap([\n    'accessKey',\n    'children',\n    'className',\n    'contentEditable',\n    'dir',\n    'draggable',\n    'hidden',\n    'htmlFor',\n    'id',\n    'lang',\n    'ref',\n    'role',\n    'style',\n    'tabIndex',\n    'title',\n    'translate',\n    'spellCheck',\n    'name', // global\n]);\n/**\n * An array of HTML element properties and events.\n *\n * @public\n */\nexport var htmlElementProperties = toObjectMap(baseElementProperties, baseElementEvents);\n/**\n * An array of LABEL tag properties and events.\n *\n * @public\n */\nexport var labelProperties = toObjectMap(htmlElementProperties, [\n    'form', // button, fieldset, input, label, meter, object, output, select, textarea\n]);\n/**\n * An array of AUDIO tag properties and events.\n\n * @public\n */\nexport var audioProperties = toObjectMap(htmlElementProperties, [\n    'height',\n    'loop',\n    'muted',\n    'preload',\n    'src',\n    'width', // canvas, embed, iframe, img, input, object, video\n]);\n/**\n * An array of VIDEO tag properties and events.\n *\n * @public\n */\nexport var videoProperties = toObjectMap(audioProperties, [\n    'poster', // video\n]);\n/**\n * An array of OL tag properties and events.\n *\n * @public\n */\nexport var olProperties = toObjectMap(htmlElementProperties, [\n    'start', // ol\n]);\n/**\n * An array of LI tag properties and events.\n *\n * @public\n */\nexport var liProperties = toObjectMap(htmlElementProperties, [\n    'value', // button, input, li, option, meter, progress, param\n]);\n/**\n * An array of A tag properties and events.\n *\n * @public\n */\nexport var anchorProperties = toObjectMap(htmlElementProperties, [\n    'download',\n    'href',\n    'hrefLang',\n    'media',\n    'rel',\n    'target',\n    'type', // a, button, input, link, menu, object, script, source, style\n]);\n/**\n * An array of BUTTON tag properties and events.\n *\n * @public\n */\nexport var buttonProperties = toObjectMap(htmlElementProperties, [\n    'autoFocus',\n    'disabled',\n    'form',\n    'formAction',\n    'formEncType',\n    'formMethod',\n    'formNoValidate',\n    'formTarget',\n    'type',\n    'value', // button, input, li, option, meter, progress, param,\n]);\n/**\n * An array of INPUT tag properties and events.\n *\n * @public\n */\nexport var inputProperties = toObjectMap(buttonProperties, [\n    'accept',\n    'alt',\n    'autoCapitalize',\n    'autoComplete',\n    'checked',\n    'dirname',\n    'form',\n    'height',\n    'inputMode',\n    'list',\n    'max',\n    'maxLength',\n    'min',\n    'minLength',\n    'multiple',\n    'pattern',\n    'placeholder',\n    'readOnly',\n    'required',\n    'src',\n    'step',\n    'size',\n    'type',\n    'value',\n    'width', // canvas, embed, iframe, img, input, object, video\n]);\n/**\n * An array of TEXTAREA tag properties and events.\n *\n * @public\n */\nexport var textAreaProperties = toObjectMap(buttonProperties, [\n    'autoCapitalize',\n    'cols',\n    'dirname',\n    'form',\n    'maxLength',\n    'minLength',\n    'placeholder',\n    'readOnly',\n    'required',\n    'rows',\n    'wrap', // textarea\n]);\n/**\n * An array of SELECT tag properties and events.\n *\n * @public\n */\nexport var selectProperties = toObjectMap(buttonProperties, [\n    'form',\n    'multiple',\n    'required', // input, select, textarea\n]);\nexport var optionProperties = toObjectMap(htmlElementProperties, [\n    'selected',\n    'value', // button, input, li, option, meter, progress, param\n]);\n/**\n * An array of TABLE tag properties and events.\n *\n * @public\n */\nexport var tableProperties = toObjectMap(htmlElementProperties, [\n    'cellPadding',\n    'cellSpacing', // table\n]);\n/**\n * An array of TR tag properties and events.\n *\n * @public\n */\nexport var trProperties = htmlElementProperties;\n/**\n * An array of TH tag properties and events.\n *\n * @public\n */\nexport var thProperties = toObjectMap(htmlElementProperties, [\n    'rowSpan',\n    'scope', // th\n]);\n/**\n * An array of TD tag properties and events.\n *\n * @public\n */\nexport var tdProperties = toObjectMap(htmlElementProperties, [\n    'colSpan',\n    'headers',\n    'rowSpan',\n    'scope', // th\n]);\nexport var colGroupProperties = toObjectMap(htmlElementProperties, [\n    'span', // col, colgroup\n]);\nexport var colProperties = toObjectMap(htmlElementProperties, [\n    'span', // col, colgroup\n]);\n/**\n * An array of FORM tag properties and events.\n *\n * @public\n */\nexport var formProperties = toObjectMap(htmlElementProperties, [\n    'acceptCharset',\n    'action',\n    'encType',\n    'encType',\n    'method',\n    'noValidate',\n    'target', // form\n]);\n/**\n * An array of IFRAME tag properties and events.\n *\n * @public\n */\nexport var iframeProperties = toObjectMap(htmlElementProperties, [\n    'allow',\n    'allowFullScreen',\n    'allowPaymentRequest',\n    'allowTransparency',\n    'csp',\n    'height',\n    'importance',\n    'referrerPolicy',\n    'sandbox',\n    'src',\n    'srcDoc',\n    'width', // canvas, embed, iframe, img, input, object, video,\n]);\n/**\n * An array of IMAGE tag properties and events.\n *\n * @public\n */\nexport var imgProperties = toObjectMap(htmlElementProperties, [\n    'alt',\n    'crossOrigin',\n    'height',\n    'src',\n    'srcSet',\n    'useMap',\n    'width', // canvas, embed, iframe, img, input, object, video\n]);\n/**\n * @deprecated Use imgProperties for img elements.\n */\nexport var imageProperties = imgProperties;\n/**\n * An array of DIV tag properties and events.\n *\n * @public\n */\nexport var divProperties = htmlElementProperties;\n/**\n * Gets native supported props for an html element provided the allowance set. Use one of the property\n * sets defined (divProperties, buttonPropertes, etc) to filter out supported properties from a given\n * props set. Note that all data- and aria- prefixed attributes will be allowed.\n * NOTE: getNativeProps should always be applied first when adding props to a react component. The\n * non-native props should be applied second. This will prevent getNativeProps from overriding your custom props.\n * For example, if props passed to getNativeProps has an onClick function and getNativeProps is added to\n * the component after an onClick function is added, then the getNativeProps onClick will override it.\n *\n * @public\n * @param props - The unfiltered input props\n * @param allowedPropsNames - The array or record of allowed prop names.\n * @returns The filtered props\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getNativeProps(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nprops, allowedPropNames, excludedPropNames) {\n    // It'd be great to properly type this while allowing 'aria-` and 'data-' attributes like TypeScript does for\n    // JSX attributes, but that ability is hardcoded into the TS compiler with no analog in TypeScript typings.\n    // Then we'd be able to enforce props extends native props (including aria- and data- attributes), and then\n    // return native props.\n    // We should be able to do this once this PR is merged: https://github.com/microsoft/TypeScript/pull/26797\n    var isArray = Array.isArray(allowedPropNames);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var result = {};\n    var keys = Object.keys(props);\n    for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {\n        var key = keys_2[_i];\n        var isNativeProp = (!isArray && allowedPropNames[key]) ||\n            (isArray && allowedPropNames.indexOf(key) >= 0) ||\n            key.indexOf('data-') === 0 ||\n            key.indexOf('aria-') === 0;\n        if (isNativeProp && (!excludedPropNames || (excludedPropNames === null || excludedPropNames === void 0 ? void 0 : excludedPropNames.indexOf(key)) === -1)) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            result[key] = props[key];\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=properties.js.map","import { createMemoizer } from '../memoize';\nfunction createComposedRenderFunction(outer) {\n    var outerMemoizer = createMemoizer(function (inner) {\n        var innerMemoizer = createMemoizer(function (defaultRender) {\n            return function (innerProps) {\n                return inner(innerProps, defaultRender);\n            };\n        });\n        return function (outerProps, defaultRender) {\n            return outer(outerProps, defaultRender ? innerMemoizer(defaultRender) : inner);\n        };\n    });\n    return outerMemoizer;\n}\nvar memoizer = createMemoizer(createComposedRenderFunction);\n/**\n * Composes two 'render functions' to produce a final render function that renders\n * the outer function, passing the inner function as 'default render'. The inner function\n * is then passed the original 'default render' prop.\n * @public\n */\nexport function composeRenderFunction(outer, inner) {\n    return memoizer(outer)(inner);\n}\n//# sourceMappingURL=composeRenderFunction.js.map","var _baseUrl = '';\n/**\n * @deprecated Unused as of version 8\n */\nexport function getResourceUrl(url) {\n    return _baseUrl + url;\n}\n/**\n * @deprecated Unused as of version 8\n */\nexport function setBaseUrl(baseUrl) {\n    _baseUrl = baseUrl;\n}\n//# sourceMappingURL=resources.js.map","import { KeyCodes } from './KeyCodes';\nimport { getDocument } from './dom/getDocument';\nimport { getItem, setItem } from './sessionStorage';\nimport { setRTL as mergeStylesSetRTL } from '@fluentui/merge-styles';\nvar RTL_LOCAL_STORAGE_KEY = 'isRTL';\n// Default to undefined so that we initialize on first read.\nvar _isRTL;\n/**\n * Gets the rtl state of the page (returns true if in rtl.)\n */\nexport function getRTL(theme) {\n    if (theme === void 0) { theme = {}; }\n    if (theme.rtl !== undefined) {\n        return theme.rtl;\n    }\n    if (_isRTL === undefined) {\n        // Fabric supports persisting the RTL setting between page refreshes via session storage\n        var savedRTL = getItem(RTL_LOCAL_STORAGE_KEY);\n        if (savedRTL !== null) {\n            _isRTL = savedRTL === '1';\n            setRTL(_isRTL);\n        }\n        var doc = getDocument();\n        if (_isRTL === undefined && doc) {\n            _isRTL = ((doc.body && doc.body.getAttribute('dir')) || doc.documentElement.getAttribute('dir')) === 'rtl';\n            mergeStylesSetRTL(_isRTL);\n        }\n    }\n    return !!_isRTL;\n}\n/**\n * Sets the rtl state of the page (by adjusting the dir attribute of the html element.)\n */\nexport function setRTL(isRTL, persistSetting) {\n    if (persistSetting === void 0) { persistSetting = false; }\n    var doc = getDocument();\n    if (doc) {\n        doc.documentElement.setAttribute('dir', isRTL ? 'rtl' : 'ltr');\n    }\n    if (persistSetting) {\n        setItem(RTL_LOCAL_STORAGE_KEY, isRTL ? '1' : '0');\n    }\n    _isRTL = isRTL;\n    mergeStylesSetRTL(_isRTL);\n}\n/**\n * Returns the given key, but flips right/left arrows if necessary.\n */\nexport function getRTLSafeKeyCode(key, theme) {\n    if (theme === void 0) { theme = {}; }\n    if (getRTL(theme)) {\n        if (key === KeyCodes.left) {\n            key = KeyCodes.right;\n        }\n        else if (key === KeyCodes.right) {\n            key = KeyCodes.left;\n        }\n    }\n    return key;\n}\n//# sourceMappingURL=rtl.js.map","import { extendComponent } from './extendComponent';\n/**\n * Generates a function to be attached to a React component, which can be called\n * as a replacement to RAF. In-flight async calls will be auto canceled if the component\n * is unmounting before the async code is executed, preventing bugs where code\n * accesses things within the component after being unmounted.\n */\nexport var safeRequestAnimationFrame = function (component) {\n    var activeTimeouts;\n    return function (cb) {\n        if (!activeTimeouts) {\n            activeTimeouts = new Set();\n            extendComponent(component, {\n                componentWillUnmount: function () {\n                    activeTimeouts.forEach(function (id) { return cancelAnimationFrame(id); });\n                },\n            });\n        }\n        var timeoutId = requestAnimationFrame(function () {\n            activeTimeouts.delete(timeoutId);\n            cb();\n        });\n        activeTimeouts.add(timeoutId);\n    };\n};\n//# sourceMappingURL=safeRequestAnimationFrame.js.map","import { extendComponent } from './extendComponent';\n/**\n * Generates a function to be attached to a React component, which can be called\n * as a replacement to setTimeout. In-flight async calls will be auto canceled if the component\n * is unmounting before the async code is executed, preventing bugs where code\n * accesses things within the component after being unmounted.\n */\nexport var safeSetTimeout = function (component) {\n    var activeTimeouts;\n    return function (cb, duration) {\n        if (!activeTimeouts) {\n            activeTimeouts = new Set();\n            extendComponent(component, {\n                componentWillUnmount: function () {\n                    activeTimeouts.forEach(function (id) { return clearTimeout(id); });\n                },\n            });\n        }\n        var timeoutId = setTimeout(function () {\n            activeTimeouts.delete(timeoutId);\n            cb();\n        }, duration);\n        activeTimeouts.add(timeoutId);\n    };\n};\n//# sourceMappingURL=safeSetTimeout.js.map","import { getDocument } from './dom/getDocument';\nimport { mergeStyles } from '@fluentui/merge-styles';\nimport { getWindow } from './dom/getWindow';\nvar _scrollbarWidth;\nvar _bodyScrollDisabledCount = 0;\nvar DisabledScrollClassName = mergeStyles({\n    overflow: 'hidden !important',\n});\n/**\n * Placing this attribute on scrollable divs optimizes detection to know\n * if the div is scrollable or not (given we can avoid expensive operations\n * like getComputedStyle.)\n *\n * @public\n */\nexport var DATA_IS_SCROLLABLE_ATTRIBUTE = 'data-is-scrollable';\n/**\n * Allows the user to scroll within a element,\n * while preventing the user from scrolling the body\n */\nexport var allowScrollOnElement = function (element, events) {\n    var window = getWindow(element);\n    if (!element || !window) {\n        return;\n    }\n    var _previousClientY = 0;\n    var _element = null;\n    var computedStyles = window.getComputedStyle(element);\n    // remember the clientY for future calls of _preventOverscrolling\n    var _saveClientY = function (event) {\n        if (event.targetTouches.length === 1) {\n            _previousClientY = event.targetTouches[0].clientY;\n        }\n    };\n    // prevent the body from scrolling when the user attempts\n    // to scroll past the top or bottom of the element\n    var _preventOverscrolling = function (event) {\n        // only respond to a single-finger touch\n        if (event.targetTouches.length !== 1) {\n            return;\n        }\n        // prevent the body touchmove handler from firing\n        // so that scrolling is allowed within the element\n        event.stopPropagation();\n        if (!_element) {\n            return;\n        }\n        var clientY = event.targetTouches[0].clientY - _previousClientY;\n        var scrollableParent = findScrollableParent(event.target);\n        if (scrollableParent && _element !== scrollableParent) {\n            _element = scrollableParent;\n            computedStyles = window.getComputedStyle(_element);\n        }\n        var scrollTop = _element.scrollTop;\n        var isColumnReverse = (computedStyles === null || computedStyles === void 0 ? void 0 : computedStyles.flexDirection) === 'column-reverse';\n        // if the element is scrolled to the top,\n        // prevent the user from scrolling up\n        if (scrollTop === 0 && (isColumnReverse ? clientY < 0 : clientY > 0)) {\n            event.preventDefault();\n        }\n        // if the element is scrolled to the bottom,\n        // prevent the user from scrolling down\n        if (_element.scrollHeight - Math.abs(Math.ceil(scrollTop)) <= _element.clientHeight &&\n            (isColumnReverse ? clientY > 0 : clientY < 0)) {\n            event.preventDefault();\n        }\n    };\n    events.on(element, 'touchstart', _saveClientY, { passive: false });\n    events.on(element, 'touchmove', _preventOverscrolling, { passive: false });\n    _element = element;\n};\n/**\n * Same as allowScrollOnElement but does not prevent overscrolling.\n */\nexport var allowOverscrollOnElement = function (element, events) {\n    if (!element) {\n        return;\n    }\n    var _allowElementScroll = function (event) {\n        event.stopPropagation();\n    };\n    events.on(element, 'touchmove', _allowElementScroll, { passive: false });\n};\nvar _disableIosBodyScroll = function (event) {\n    event.preventDefault();\n};\n/**\n * Disables the body scrolling.\n *\n * @public\n */\nexport function disableBodyScroll() {\n    var doc = getDocument();\n    if (doc && doc.body && !_bodyScrollDisabledCount) {\n        doc.body.classList.add(DisabledScrollClassName);\n        doc.body.addEventListener('touchmove', _disableIosBodyScroll, { passive: false, capture: false });\n    }\n    _bodyScrollDisabledCount++;\n}\n/**\n * Enables the body scrolling.\n *\n * @public\n */\nexport function enableBodyScroll() {\n    if (_bodyScrollDisabledCount > 0) {\n        var doc = getDocument();\n        if (doc && doc.body && _bodyScrollDisabledCount === 1) {\n            doc.body.classList.remove(DisabledScrollClassName);\n            doc.body.removeEventListener('touchmove', _disableIosBodyScroll);\n        }\n        _bodyScrollDisabledCount--;\n    }\n}\n/**\n * Calculates the width of a scrollbar for the browser/os.\n *\n * @public\n */\nexport function getScrollbarWidth(doc) {\n    if (_scrollbarWidth === undefined) {\n        var theDoc = doc !== null && doc !== void 0 ? doc : getDocument();\n        var scrollDiv = theDoc.createElement('div');\n        scrollDiv.style.setProperty('width', '100px');\n        scrollDiv.style.setProperty('height', '100px');\n        scrollDiv.style.setProperty('overflow', 'scroll');\n        scrollDiv.style.setProperty('position', 'absolute');\n        scrollDiv.style.setProperty('top', '-9999px');\n        theDoc.body.appendChild(scrollDiv);\n        // Get the scrollbar width\n        _scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n        // Delete the DIV\n        theDoc.body.removeChild(scrollDiv);\n    }\n    return _scrollbarWidth;\n}\n/**\n * Traverses up the DOM for the element with the data-is-scrollable=true attribute, or returns\n * document.body.\n *\n * @public\n */\nexport function findScrollableParent(startingElement) {\n    var el = startingElement;\n    var doc = getDocument(startingElement);\n    // First do a quick scan for the scrollable attribute.\n    while (el && el !== doc.body) {\n        if (el.getAttribute(DATA_IS_SCROLLABLE_ATTRIBUTE) === 'true') {\n            return el;\n        }\n        el = el.parentElement;\n    }\n    // If we haven't found it, the use the slower method: compute styles to evaluate if overflow is set.\n    el = startingElement;\n    while (el && el !== doc.body) {\n        if (el.getAttribute(DATA_IS_SCROLLABLE_ATTRIBUTE) !== 'false') {\n            var computedStyles = getComputedStyle(el);\n            var overflowY = computedStyles ? computedStyles.getPropertyValue('overflow-y') : '';\n            if (overflowY && (overflowY === 'scroll' || overflowY === 'auto')) {\n                return el;\n            }\n        }\n        el = el.parentElement;\n    }\n    // Fall back to window scroll.\n    if (!el || el === doc.body) {\n        el = getWindow(startingElement);\n    }\n    return el;\n}\n//# sourceMappingURL=scroll.js.map","import { SELECTION_CHANGE, SelectionMode, SELECTION_ITEMS_CHANGE } from './Selection.types';\nimport { EventGroup } from '../EventGroup';\n/**\n * {@docCategory Selection}\n */\nvar Selection = /** @class */ (function () {\n    /**\n     * Create a new Selection. If `TItem` does not have a `key` property, you must provide an options\n     * object with a `getKey` implementation. Providing options is optional otherwise.\n     * (At most one `options` object is accepted.)\n     */\n    function Selection() {\n        var options = []; // Otherwise, arguments require options with `getKey`.\n        for (var _i = 0 // Otherwise, arguments require options with `getKey`.\n        ; _i < arguments.length // Otherwise, arguments require options with `getKey`.\n        ; _i++ // Otherwise, arguments require options with `getKey`.\n        ) {\n            options[_i] = arguments[_i]; // Otherwise, arguments require options with `getKey`.\n        }\n        var _a = options[0] || {}, onSelectionChanged = _a.onSelectionChanged, onItemsChanged = _a.onItemsChanged, getKey = _a.getKey, _b = _a.canSelectItem, canSelectItem = _b === void 0 ? function () { return true; } : _b, items = _a.items, _c = _a.selectionMode, selectionMode = _c === void 0 ? SelectionMode.multiple : _c;\n        this.mode = selectionMode;\n        this._getKey = getKey || defaultGetKey;\n        this._changeEventSuppressionCount = 0;\n        this._exemptedCount = 0;\n        this._anchoredIndex = 0;\n        this._unselectableCount = 0;\n        this._onSelectionChanged = onSelectionChanged;\n        this._onItemsChanged = onItemsChanged;\n        this._canSelectItem = canSelectItem;\n        this._keyToIndexMap = {};\n        this._isModal = false;\n        this.setItems(items || [], true);\n        this.count = this.getSelectedCount();\n    }\n    Selection.prototype.canSelectItem = function (item, index) {\n        if (typeof index === 'number' && index < 0) {\n            return false;\n        }\n        return this._canSelectItem(item, index);\n    };\n    Selection.prototype.getKey = function (item, index) {\n        var key = this._getKey(item, index);\n        return typeof key === 'number' || key ? \"\".concat(key) : '';\n    };\n    Selection.prototype.setChangeEvents = function (isEnabled, suppressChange) {\n        this._changeEventSuppressionCount += isEnabled ? -1 : 1;\n        if (this._changeEventSuppressionCount === 0 && this._hasChanged) {\n            this._hasChanged = false;\n            if (!suppressChange) {\n                this._change();\n            }\n        }\n    };\n    Selection.prototype.isModal = function () {\n        return this._isModal;\n    };\n    Selection.prototype.setModal = function (isModal) {\n        if (this._isModal !== isModal) {\n            this.setChangeEvents(false);\n            this._isModal = isModal;\n            if (!isModal) {\n                this.setAllSelected(false);\n            }\n            this._change();\n            this.setChangeEvents(true);\n        }\n    };\n    /**\n     * Selection needs the items, call this method to set them. If the set\n     * of items is the same, this will re-evaluate selection and index maps.\n     * Otherwise, shouldClear should be set to true, so that selection is\n     * cleared.\n     */\n    Selection.prototype.setItems = function (items, shouldClear) {\n        if (shouldClear === void 0) { shouldClear = true; }\n        var newKeyToIndexMap = {};\n        var newUnselectableIndices = {};\n        var hasSelectionChanged = false;\n        this.setChangeEvents(false);\n        // Reset the unselectable count.\n        this._unselectableCount = 0;\n        var haveItemsChanged = false;\n        // Build lookup table for quick selection evaluation.\n        for (var i = 0; i < items.length; i++) {\n            var item = items[i];\n            if (item) {\n                var key = this.getKey(item, i);\n                if (key) {\n                    if (!haveItemsChanged && (!(key in this._keyToIndexMap) || this._keyToIndexMap[key] !== i)) {\n                        haveItemsChanged = true;\n                    }\n                    newKeyToIndexMap[key] = i;\n                }\n            }\n            newUnselectableIndices[i] = item && !this.canSelectItem(item);\n            if (newUnselectableIndices[i]) {\n                this._unselectableCount++;\n            }\n        }\n        if (shouldClear || items.length === 0) {\n            this._setAllSelected(false, true);\n        }\n        // Check the exemption list for discrepencies.\n        var newExemptedIndicies = {};\n        var newExemptedCount = 0;\n        for (var indexProperty in this._exemptedIndices) {\n            if (this._exemptedIndices.hasOwnProperty(indexProperty)) {\n                var index = Number(indexProperty);\n                var item = this._items[index];\n                var exemptKey = item ? this.getKey(item, Number(index)) : undefined;\n                var newIndex = exemptKey ? newKeyToIndexMap[exemptKey] : index;\n                if (newIndex === undefined) {\n                    // The item has likely been replaced or removed.\n                    hasSelectionChanged = true;\n                }\n                else {\n                    // We know the new index of the item. update the existing exemption table.\n                    newExemptedIndicies[newIndex] = true;\n                    newExemptedCount++;\n                    hasSelectionChanged = hasSelectionChanged || newIndex !== index;\n                }\n            }\n        }\n        if (this._items && this._exemptedCount === 0 && items.length !== this._items.length && this._isAllSelected) {\n            // If everything was selected but the number of items has changed, selection has changed.\n            hasSelectionChanged = true;\n        }\n        if (!haveItemsChanged) {\n            for (var _i = 0, _a = Object.keys(this._keyToIndexMap); _i < _a.length; _i++) {\n                var key = _a[_i];\n                if (!(key in newKeyToIndexMap)) {\n                    haveItemsChanged = true;\n                    break;\n                }\n            }\n        }\n        this._exemptedIndices = newExemptedIndicies;\n        this._exemptedCount = newExemptedCount;\n        this._keyToIndexMap = newKeyToIndexMap;\n        this._unselectableIndices = newUnselectableIndices;\n        this._items = items;\n        this._selectedItems = null;\n        if (hasSelectionChanged) {\n            this._updateCount();\n        }\n        if (haveItemsChanged) {\n            EventGroup.raise(this, SELECTION_ITEMS_CHANGE);\n            if (this._onItemsChanged) {\n                this._onItemsChanged();\n            }\n        }\n        if (hasSelectionChanged) {\n            this._change();\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype.getItems = function () {\n        return this._items;\n    };\n    Selection.prototype.getSelection = function () {\n        if (!this._selectedItems) {\n            this._selectedItems = [];\n            var items = this._items;\n            if (items) {\n                for (var i = 0; i < items.length; i++) {\n                    if (this.isIndexSelected(i)) {\n                        this._selectedItems.push(items[i]);\n                    }\n                }\n            }\n        }\n        return this._selectedItems;\n    };\n    Selection.prototype.getSelectedCount = function () {\n        return this._isAllSelected\n            ? this._items.length - this._exemptedCount - this._unselectableCount\n            : this._exemptedCount;\n    };\n    Selection.prototype.getSelectedIndices = function () {\n        if (!this._selectedIndices) {\n            this._selectedIndices = [];\n            var items = this._items;\n            if (items) {\n                for (var i = 0; i < items.length; i++) {\n                    if (this.isIndexSelected(i)) {\n                        this._selectedIndices.push(i);\n                    }\n                }\n            }\n        }\n        return this._selectedIndices;\n    };\n    Selection.prototype.getItemIndex = function (key) {\n        var index = this._keyToIndexMap[key];\n        return index !== null && index !== void 0 ? index : -1;\n    };\n    Selection.prototype.isRangeSelected = function (fromIndex, count) {\n        if (count === 0) {\n            return false;\n        }\n        var endIndex = fromIndex + count;\n        for (var i = fromIndex; i < endIndex; i++) {\n            if (!this.isIndexSelected(i)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    Selection.prototype.isAllSelected = function () {\n        var selectableCount = this._items.length - this._unselectableCount;\n        // In single mode, we can only have a max of 1 item.\n        if (this.mode === SelectionMode.single) {\n            selectableCount = Math.min(selectableCount, 1);\n        }\n        return ((this.count > 0 && this._isAllSelected && this._exemptedCount === 0) ||\n            (!this._isAllSelected && this._exemptedCount === selectableCount && selectableCount > 0));\n    };\n    Selection.prototype.isKeySelected = function (key) {\n        var index = this._keyToIndexMap[key];\n        return this.isIndexSelected(index);\n    };\n    Selection.prototype.isIndexSelected = function (index) {\n        return !!((this.count > 0 && this._isAllSelected && !this._exemptedIndices[index] && !this._unselectableIndices[index]) ||\n            (!this._isAllSelected && this._exemptedIndices[index]));\n    };\n    Selection.prototype.setAllSelected = function (isAllSelected) {\n        if (isAllSelected && this.mode !== SelectionMode.multiple) {\n            return;\n        }\n        var selectableCount = this._items ? this._items.length - this._unselectableCount : 0;\n        this.setChangeEvents(false);\n        if (selectableCount > 0 && (this._exemptedCount > 0 || isAllSelected !== this._isAllSelected)) {\n            this._exemptedIndices = {};\n            if (isAllSelected !== this._isAllSelected || this._exemptedCount > 0) {\n                this._exemptedCount = 0;\n                this._isAllSelected = isAllSelected;\n                this._change();\n            }\n            this._updateCount();\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype.setKeySelected = function (key, isSelected, shouldAnchor) {\n        var index = this._keyToIndexMap[key];\n        if (index >= 0) {\n            this.setIndexSelected(index, isSelected, shouldAnchor);\n        }\n    };\n    Selection.prototype.setIndexSelected = function (index, isSelected, shouldAnchor) {\n        if (this.mode === SelectionMode.none) {\n            return;\n        }\n        // Clamp the index.\n        index = Math.min(Math.max(0, index), this._items.length - 1);\n        // No-op on out of bounds selections.\n        if (index < 0 || index >= this._items.length) {\n            return;\n        }\n        this.setChangeEvents(false);\n        var isExempt = this._exemptedIndices[index];\n        var canSelect = !this._unselectableIndices[index];\n        if (canSelect) {\n            if (isSelected && this.mode === SelectionMode.single) {\n                // If this is single-select, the previous selection should be removed.\n                this._setAllSelected(false, true);\n            }\n            // Determine if we need to remove the exemption.\n            if (isExempt && ((isSelected && this._isAllSelected) || (!isSelected && !this._isAllSelected))) {\n                delete this._exemptedIndices[index];\n                this._exemptedCount--;\n            }\n            // Determine if we need to add the exemption.\n            if (!isExempt && ((isSelected && !this._isAllSelected) || (!isSelected && this._isAllSelected))) {\n                this._exemptedIndices[index] = true;\n                this._exemptedCount++;\n            }\n            if (shouldAnchor) {\n                this._anchoredIndex = index;\n            }\n        }\n        this._updateCount();\n        this.setChangeEvents(true);\n    };\n    Selection.prototype.setRangeSelected = function (fromIndex, count, isSelected, shouldAnchor) {\n        if (this.mode === SelectionMode.none) {\n            return;\n        }\n        // Clamp the index.\n        fromIndex = Math.min(Math.max(0, fromIndex), this._items.length - 1);\n        // Clamp the range.\n        count = Math.min(Math.max(0, count), this._items.length - fromIndex);\n        // No-op on out of bounds selections.\n        if (fromIndex < 0 || fromIndex >= this._items.length || count === 0) {\n            return;\n        }\n        this.setChangeEvents(false);\n        var anchorIndex = this._anchoredIndex || 0;\n        var startIndex = fromIndex;\n        var endIndex = fromIndex + count - 1;\n        var newAnchorIndex = anchorIndex >= endIndex ? startIndex : endIndex;\n        for (; startIndex <= endIndex; startIndex++) {\n            this.setIndexSelected(startIndex, isSelected, shouldAnchor ? startIndex === newAnchorIndex : false);\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype.selectToKey = function (key, clearSelection) {\n        this.selectToIndex(this._keyToIndexMap[key], clearSelection);\n    };\n    Selection.prototype.selectToRange = function (fromIndex, count, clearSelection) {\n        if (this.mode === SelectionMode.none) {\n            return;\n        }\n        if (this.mode === SelectionMode.single) {\n            if (count === 1) {\n                this.setIndexSelected(fromIndex, true, true);\n            }\n            return;\n        }\n        var anchorIndex = this._anchoredIndex || 0;\n        var startIndex = Math.min(fromIndex, anchorIndex);\n        var endIndex = Math.max(fromIndex + count - 1, anchorIndex);\n        this.setChangeEvents(false);\n        if (clearSelection) {\n            this._setAllSelected(false, true);\n        }\n        for (; startIndex <= endIndex; startIndex++) {\n            this.setIndexSelected(startIndex, true, false);\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype.selectToIndex = function (index, clearSelection) {\n        if (this.mode === SelectionMode.none) {\n            return;\n        }\n        if (this.mode === SelectionMode.single) {\n            this.setIndexSelected(index, true, true);\n            return;\n        }\n        var anchorIndex = this._anchoredIndex || 0;\n        var startIndex = Math.min(index, anchorIndex);\n        var endIndex = Math.max(index, anchorIndex);\n        this.setChangeEvents(false);\n        if (clearSelection) {\n            this._setAllSelected(false, true);\n        }\n        for (; startIndex <= endIndex; startIndex++) {\n            this.setIndexSelected(startIndex, true, false);\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype.toggleAllSelected = function () {\n        this.setAllSelected(!this.isAllSelected());\n    };\n    Selection.prototype.toggleKeySelected = function (key) {\n        this.setKeySelected(key, !this.isKeySelected(key), true);\n    };\n    Selection.prototype.toggleIndexSelected = function (index) {\n        this.setIndexSelected(index, !this.isIndexSelected(index), true);\n    };\n    Selection.prototype.toggleRangeSelected = function (fromIndex, count) {\n        if (this.mode === SelectionMode.none) {\n            return;\n        }\n        var isRangeSelected = this.isRangeSelected(fromIndex, count);\n        var endIndex = fromIndex + count;\n        if (this.mode === SelectionMode.single && count > 1) {\n            return;\n        }\n        this.setChangeEvents(false);\n        for (var i = fromIndex; i < endIndex; i++) {\n            this.setIndexSelected(i, !isRangeSelected, false);\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype._updateCount = function (preserveModalState) {\n        if (preserveModalState === void 0) { preserveModalState = false; }\n        var count = this.getSelectedCount();\n        if (count !== this.count) {\n            this.count = count;\n            this._change();\n        }\n        if (!this.count && !preserveModalState) {\n            this.setModal(false);\n        }\n    };\n    Selection.prototype._setAllSelected = function (isAllSelected, preserveModalState) {\n        if (preserveModalState === void 0) { preserveModalState = false; }\n        if (isAllSelected && this.mode !== SelectionMode.multiple) {\n            return;\n        }\n        var selectableCount = this._items ? this._items.length - this._unselectableCount : 0;\n        this.setChangeEvents(false);\n        if (selectableCount > 0 && (this._exemptedCount > 0 || isAllSelected !== this._isAllSelected)) {\n            this._exemptedIndices = {};\n            if (isAllSelected !== this._isAllSelected || this._exemptedCount > 0) {\n                this._exemptedCount = 0;\n                this._isAllSelected = isAllSelected;\n                this._change();\n            }\n            this._updateCount(preserveModalState);\n        }\n        this.setChangeEvents(true);\n    };\n    Selection.prototype._change = function () {\n        if (this._changeEventSuppressionCount === 0) {\n            this._selectedItems = null;\n            this._selectedIndices = undefined;\n            EventGroup.raise(this, SELECTION_CHANGE);\n            if (this._onSelectionChanged) {\n                this._onSelectionChanged();\n            }\n        }\n        else {\n            this._hasChanged = true;\n        }\n    };\n    return Selection;\n}());\nexport { Selection };\nfunction defaultGetKey(item, index) {\n    // 0 may be used as a key\n    var _a = (item || {}).key, key = _a === void 0 ? \"\".concat(index) : _a;\n    return key;\n}\n//# sourceMappingURL=Selection.js.map","export var SELECTION_CHANGE = 'change';\nexport var SELECTION_ITEMS_CHANGE = 'items-change';\n/**\n * {@docCategory Selection}\n */\nexport var SelectionMode;\n(function (SelectionMode) {\n    SelectionMode[SelectionMode[\"none\"] = 0] = \"none\";\n    SelectionMode[SelectionMode[\"single\"] = 1] = \"single\";\n    SelectionMode[SelectionMode[\"multiple\"] = 2] = \"multiple\";\n})(SelectionMode || (SelectionMode = {}));\n/**\n * {@docCategory Selection}\n */\nexport var SelectionDirection;\n(function (SelectionDirection) {\n    SelectionDirection[SelectionDirection[\"horizontal\"] = 0] = \"horizontal\";\n    SelectionDirection[SelectionDirection[\"vertical\"] = 1] = \"vertical\";\n})(SelectionDirection || (SelectionDirection = {}));\n//# sourceMappingURL=Selection.types.js.map","import { getWindow } from './dom/getWindow';\n/**\n * Fetches an item from session storage without throwing an exception\n * @param key The key of the item to fetch from session storage\n */\nexport function getItem(key) {\n    var result = null;\n    try {\n        var win = getWindow();\n        result = win ? win.sessionStorage.getItem(key) : null;\n    }\n    catch (e) {\n        /* Eat the exception */\n    }\n    return result;\n}\n/**\n * Inserts an item into session storage without throwing an exception\n * @param key The key of the item to add to session storage\n * @param data The data to put into session storage\n */\nexport function setItem(key, data) {\n    var _a;\n    try {\n        (_a = getWindow()) === null || _a === void 0 ? void 0 : _a.sessionStorage.setItem(key, data);\n    }\n    catch (e) {\n        /* Eat the exception */\n    }\n}\n//# sourceMappingURL=sessionStorage.js.map","import { getWindow } from './dom/getWindow';\nexport var IsFocusVisibleClassName = 'ms-Fabric--isFocusVisible';\nexport var IsFocusHiddenClassName = 'ms-Fabric--isFocusHidden';\nfunction updateClassList(el, enabled) {\n    if (el) {\n        el.classList.add(enabled ? IsFocusVisibleClassName : IsFocusHiddenClassName);\n        el.classList.remove(enabled ? IsFocusHiddenClassName : IsFocusVisibleClassName);\n    }\n}\n/**\n * Sets the visibility of focus styling.\n *\n * By default, focus styles (the box surrounding a focused Button, for example) only show up when navigational\n * keypresses occur (through Tab, arrows, PgUp/PgDn, Home and End), and are hidden when mouse interactions occur.\n * This API provides an imperative way to turn them on/off.\n *\n * A use case might be when you have a keypress like ctrl-f6 navigate to a particular region on the page,\n * and want focus to show up.\n *\n * @param enabled - Whether to turn focus visibility on or off.\n * @param target - Optional target from which to get window in case no `providerElem` has been specified.\n * @param registeredProviders - Array of provider refs that are associated with a FocusRectsProvider. If no array\n *                              is passed in, the classnames are attached to the document body that contains `target`.\n */\nexport function setFocusVisibility(enabled, target, registeredProviders) {\n    var _a;\n    if (registeredProviders) {\n        registeredProviders.forEach(function (ref) { return updateClassList(ref.current, enabled); });\n    }\n    else {\n        updateClassList((_a = getWindow(target)) === null || _a === void 0 ? void 0 : _a.document.body, enabled);\n    }\n}\n//# sourceMappingURL=setFocusVisibility.js.map","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nimport { GLOBAL_STYLESHEET_KEY } from '@fluentui/merge-styles';\nimport { useMergeStylesHooks } from '../hooks/useMergeStylesHooks';\nexport var MergeStylesShadowRootContext = React.createContext(undefined);\n/**\n * Context for a shadow root.\n */\nexport var MergeStylesShadowRootProvider = function (_a) {\n    var shadowRoot = _a.shadowRoot, props = __rest(_a, [\"shadowRoot\"]);\n    var value = React.useMemo(function () {\n        return {\n            stylesheets: new Map(),\n            shadowRoot: shadowRoot,\n        };\n    }, [shadowRoot]);\n    return (React.createElement(MergeStylesShadowRootContext.Provider, __assign({ value: value }, props),\n        React.createElement(GlobalStyles, null),\n        props.children));\n};\nvar GlobalStyles = function (props) {\n    var useAdoptedStylesheet = useMergeStylesHooks().useAdoptedStylesheet;\n    useAdoptedStylesheet(GLOBAL_STYLESHEET_KEY);\n    return null;\n};\n//# sourceMappingURL=MergeStylesShadowRootContext.js.map","import { DEFAULT_SHADOW_CONFIG } from '@fluentui/merge-styles';\nimport * as React from 'react';\nexport var noop = function () { return false; };\nexport var noopShadow = function () { return DEFAULT_SHADOW_CONFIG; };\nexport var noopRootStylesheets = function () { return new Map(); };\nexport var noopUndefined = function () { return undefined; };\nexport var getNewContext = function () {\n    return {\n        stylesheets: new Map(),\n        useAdoptedStylesheetEx: noop,\n        useAdoptedStylesheet: noop,\n        useShadowConfig: noopShadow,\n        useMergeStylesShadowRootContext: noopUndefined,\n        useHasMergeStylesShadowRootContext: noop,\n        useMergeStylesRootStylesheets: noopRootStylesheets,\n        useWindow: noopUndefined,\n        useStyled: noopUndefined,\n    };\n};\nexport var MergeStylesDefaultContext = React.createContext(getNewContext());\n//# sourceMappingURL=MergeStylesDefaultContext.js.map","import * as React from 'react';\nimport { MergeStylesDefaultContext } from '../contexts/MergeStylesDefaultContext';\nexport var useMergeStylesHooks = function () {\n    var ctx = React.useContext(MergeStylesDefaultContext);\n    return {\n        useAdoptedStylesheet: ctx.useAdoptedStylesheet,\n        useAdoptedStylesheetEx: ctx.useAdoptedStylesheetEx,\n        useShadowConfig: ctx.useShadowConfig,\n        useMergeStylesShadowRootContext: ctx.useMergeStylesShadowRootContext,\n        useHasMergeStylesShadowRootContext: ctx.useHasMergeStylesShadowRootContext,\n        useMergeStylesRootStylesheets: ctx.useMergeStylesRootStylesheets,\n        useWindow: ctx.useWindow,\n        useStyled: ctx.useStyled,\n    };\n};\n//# sourceMappingURL=useMergeStylesHooks.js.map","// Regex that finds { and } so they can be removed on a lookup for string format\nvar FORMAT_ARGS_REGEX = /[\\{\\}]/g;\n// Regex that finds {#} so it can be replaced by the arguments in string format\nvar FORMAT_REGEX = /\\{\\d+\\}/g;\n/**\n * String format method, used for scenarios where at runtime you\n * need to evaluate a formatted string given a tokenized string. This\n * usually only is needed in localization scenarios.\n\n * @example\n * ```tsx\n * \"I love {0} every {1}\".format(\"CXP\")\n * ```\n * will result in a Debug Exception.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function format(s) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    var args = values;\n    // Callback match function\n    function replaceFunc(match) {\n        // looks up in the args\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var replacement = args[match.replace(FORMAT_ARGS_REGEX, '')];\n        // catches undefined in nondebug and null in debug and nondebug\n        if (replacement === null || replacement === undefined) {\n            replacement = '';\n        }\n        return replacement;\n    }\n    return s.replace(FORMAT_REGEX, replaceFunc);\n}\n//# sourceMappingURL=string.js.map","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nimport { concatStyleSetsWithProps } from '@fluentui/merge-styles';\nimport { useMergeStylesHooks } from './shadowDom/index';\nimport { useCustomizationSettings } from './customizations/useCustomizationSettings';\nvar DefaultFields = ['theme', 'styles'];\nexport function styled(Component, baseStyles, getProps, customizable, pure) {\n    customizable = customizable || { scope: '', fields: undefined };\n    var scope = customizable.scope, _a = customizable.fields, fields = _a === void 0 ? DefaultFields : _a;\n    var Wrapped = React.forwardRef(function (props, forwardedRef) {\n        var styles = React.useRef();\n        var settings = useCustomizationSettings(fields, scope);\n        var customizedStyles = settings.styles, dir = settings.dir, rest = __rest(settings, [\"styles\", \"dir\"]);\n        var additionalProps = getProps ? getProps(props) : undefined;\n        var useStyled = useMergeStylesHooks().useStyled;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var cache = (styles.current && styles.current.__cachedInputs__) || [];\n        var propStyles = props.styles;\n        if (!styles.current || customizedStyles !== cache[1] || propStyles !== cache[2]) {\n            // Using styled components as the Component arg will result in nested styling arrays.\n            // The function can be cached and in order to prevent the props from being retained within it's closure\n            // we pass in just the styles and not the entire props\n            var concatenatedStyles = function (styleProps) {\n                return concatStyleSetsWithProps(styleProps, baseStyles, customizedStyles, propStyles);\n            };\n            // The __cachedInputs__ array is attached to the function and consumed by the\n            // classNamesFunction as a list of keys to include for memoizing classnames.\n            concatenatedStyles.__cachedInputs__ = [\n                baseStyles,\n                customizedStyles,\n                propStyles,\n            ];\n            concatenatedStyles.__noStyleOverride__ =\n                !customizedStyles && !propStyles;\n            styles.current = concatenatedStyles;\n        }\n        styles.current.__shadowConfig__ = useStyled(scope);\n        return React.createElement(Component, __assign({ ref: forwardedRef }, rest, additionalProps, props, { styles: styles.current }));\n    });\n    // Function.prototype.name is an ES6 feature, so the cast to any is required until we're\n    // able to drop IE 11 support and compile with ES6 libs\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Wrapped.displayName = \"Styled\".concat(Component.displayName || Component.name);\n    // This preserves backwards compatibility.\n    var pureComponent = pure ? React.memo(Wrapped) : Wrapped;\n    // Check if the wrapper has a displayName after it has been memoized. Then assign it to the pure component.\n    if (Wrapped.displayName) {\n        pureComponent.displayName = Wrapped.displayName;\n    }\n    return pureComponent;\n}\n//# sourceMappingURL=styled.js.map","import * as React from 'react';\nimport { getWindow } from './dom/getWindow';\nimport { isDirectionalKeyCode } from './keyboard';\nimport { setFocusVisibility } from './setFocusVisibility';\nvar mountCounters = new WeakMap();\nvar callbackMap = new WeakMap();\nfunction setMountCounters(key, delta) {\n    var newValue;\n    var currValue = mountCounters.get(key);\n    if (currValue) {\n        newValue = currValue + delta;\n    }\n    else {\n        newValue = 1;\n    }\n    mountCounters.set(key, newValue);\n    return newValue;\n}\nfunction setCallbackMap(context) {\n    var callbacks = callbackMap.get(context);\n    if (callbacks) {\n        return callbacks;\n    }\n    var onMouseDown = function (ev) { return _onMouseDown(ev, context.registeredProviders); };\n    var onPointerDown = function (ev) { return _onPointerDown(ev, context.registeredProviders); };\n    var onKeyDown = function (ev) { return _onKeyDown(ev, context.registeredProviders); };\n    var onKeyUp = function (ev) { return _onKeyUp(ev, context.registeredProviders); };\n    callbacks = { onMouseDown: onMouseDown, onPointerDown: onPointerDown, onKeyDown: onKeyDown, onKeyUp: onKeyUp };\n    callbackMap.set(context, callbacks);\n    return callbacks;\n}\nexport var FocusRectsContext = React.createContext(undefined);\n/**\n * Initializes the logic which:\n *\n * 1. Subscribes keydown, keyup, mousedown and pointerdown events. (It will only do it once for the current element of\n *    the FocusRectsContext providerRef or once per window if no such element is provided via context, so it's safe to\n *    call this method multiple times.)\n * 2. When the user presses triggers a keydown or keyup event via directional keyboard keys, adds the\n *    'ms-Fabric--isFocusVisible' classname to the current element of the FocusRectsContext providerRef or the document\n *    body if no such element is provided via context, and removes the 'ms-Fabric-isFocusHidden' classname.\n * 3. When the user triggers a mousedown or pointerdown event, adds the 'ms-Fabric-isFocusHidden' classname to the\n *    current element of the FocusRectsContext providerRef or the document body if no such element is provided via\n *    context, and removes the 'ms-Fabric--isFocusVisible' classname.\n *\n * This logic allows components on the page to conditionally render focus treatments based on\n * the existence of global classnames, which simplifies logic overall.\n *\n * @param rootRef - A Ref object. Focus rectangle can be applied on itself and all its children.\n */\nexport function useFocusRects(rootRef) {\n    var context = React.useContext(FocusRectsContext);\n    React.useEffect(function () {\n        var _a, _b, _c, _d;\n        var win = getWindow(rootRef === null || rootRef === void 0 ? void 0 : rootRef.current);\n        if (!win || ((_a = win.FabricConfig) === null || _a === void 0 ? void 0 : _a.disableFocusRects) === true) {\n            return undefined;\n        }\n        var el = win;\n        var onMouseDown;\n        var onPointerDown;\n        var onKeyDown;\n        var onKeyUp;\n        if (((_b = context === null || context === void 0 ? void 0 : context.providerRef) === null || _b === void 0 ? void 0 : _b.current) &&\n            ((_d = (_c = context === null || context === void 0 ? void 0 : context.providerRef) === null || _c === void 0 ? void 0 : _c.current) === null || _d === void 0 ? void 0 : _d.addEventListener)) {\n            el = context.providerRef.current;\n            // The NOINLINE directive tells terser not to move the setCallbackMap implementation into the call site during\n            // minification.\n            // This prevents the function from capturing additional variables in the closure, which can cause memory leaks.\n            var callbacks = /*@__NOINLINE__*/ setCallbackMap(context);\n            onMouseDown = callbacks.onMouseDown;\n            onPointerDown = callbacks.onPointerDown;\n            onKeyDown = callbacks.onKeyDown;\n            onKeyUp = callbacks.onKeyUp;\n        }\n        else {\n            onMouseDown = _onMouseDown;\n            onPointerDown = _onPointerDown;\n            onKeyDown = _onKeyDown;\n            onKeyUp = _onKeyUp;\n        }\n        var count = setMountCounters(el, 1);\n        if (count <= 1) {\n            el.addEventListener('mousedown', onMouseDown, true);\n            el.addEventListener('pointerdown', onPointerDown, true);\n            el.addEventListener('keydown', onKeyDown, true);\n            el.addEventListener('keyup', onKeyUp, true);\n        }\n        return function () {\n            var _a;\n            if (!win || ((_a = win.FabricConfig) === null || _a === void 0 ? void 0 : _a.disableFocusRects) === true) {\n                return;\n            }\n            count = setMountCounters(el, -1);\n            if (count === 0) {\n                el.removeEventListener('mousedown', onMouseDown, true);\n                el.removeEventListener('pointerdown', onPointerDown, true);\n                el.removeEventListener('keydown', onKeyDown, true);\n                el.removeEventListener('keyup', onKeyUp, true);\n            }\n        };\n    }, [context, rootRef]);\n}\n/**\n * Function Component wrapper which enables calling `useFocusRects` hook.\n * Renders nothing.\n */\nexport var FocusRects = function (props) {\n    useFocusRects(props.rootRef);\n    return null;\n};\nfunction _onMouseDown(ev, registeredProviders) {\n    setFocusVisibility(false, ev.target, registeredProviders);\n}\nfunction _onPointerDown(ev, registeredProviders) {\n    if (ev.pointerType !== 'mouse') {\n        setFocusVisibility(false, ev.target, registeredProviders);\n    }\n}\n// You need both a keydown and a keyup listener that sets focus visibility to true to handle two distinct scenarios when\n// attaching the listeners and classnames to the provider instead of the document body.\n// If you only have a keydown listener, then the focus rectangles will not show when moving from outside of the provider\n// to inside it. That is why a keyup listener is needed, since it will always trigger after the focus event is fired.\n// If you only have a keyup listener, then the focus rectangles will not show moving between different tabbable elements\n// if the tab key is pressed without being released. That's is why we need a keydown listener, since it will trigger for\n// every element that is being tabbed into.\n// This works because `classList.add` is smart and will not duplicate a classname that already exists on the classList\n// when focus visibility is turned on.\nfunction _onKeyDown(ev, registeredProviders) {\n    // eslint-disable-next-line deprecation/deprecation\n    if (isDirectionalKeyCode(ev.which)) {\n        setFocusVisibility(true, ev.target, registeredProviders);\n    }\n}\nfunction _onKeyUp(ev, registeredProviders) {\n    // eslint-disable-next-line deprecation/deprecation\n    if (isDirectionalKeyCode(ev.which)) {\n        setFocusVisibility(true, ev.target, registeredProviders);\n    }\n}\n//# sourceMappingURL=useFocusRects.js.map","/* eslint-disable no-console */\nvar _warningCallback = undefined;\n/**\n * Sends a warning to console, if the api is present.\n *\n * @public\n * @param message - Warning message.\n */\nexport function warn(message) {\n    if (_warningCallback && process.env.NODE_ENV !== 'production') {\n        _warningCallback(message);\n    }\n    else if (console && console.warn) {\n        console.warn(message);\n    }\n}\n/**\n * Configures the warning callback. Passing in undefined will reset it to use the default\n * console.warn function.\n *\n * @public\n * @param warningCallback - Callback to override the generated warnings.\n */\nexport function setWarningCallback(warningCallback) {\n    _warningCallback = warningCallback;\n}\n//# sourceMappingURL=warn.js.map","import { warn } from './warn';\n/**\n * Warns when props are required if a condition is met.\n *\n * @public\n * @param componentName - The name of the component being used.\n * @param props - The props passed into the component.\n * @param requiredProps - The name of the props that are required when the condition is met.\n * @param conditionalPropName - The name of the prop that the condition is based on.\n * @param condition - Whether the condition is met.\n */\nexport function warnConditionallyRequiredProps(componentName, props, requiredProps, conditionalPropName, condition) {\n    if (condition === true && process.env.NODE_ENV !== 'production') {\n        for (var _i = 0, requiredProps_1 = requiredProps; _i < requiredProps_1.length; _i++) {\n            var requiredPropName = requiredProps_1[_i];\n            if (!(requiredPropName in props)) {\n                warn(\"\".concat(componentName, \" property '\").concat(requiredPropName, \"' is required when '\").concat(conditionalPropName, \"' is used.'\"));\n            }\n        }\n    }\n}\n//# sourceMappingURL=warnConditionallyRequiredProps.js.map","import { warn } from './warn';\nimport { isControlled as checkIsControlled } from '../controlled';\nvar warningsMap;\nif (process.env.NODE_ENV !== 'production') {\n    warningsMap = {\n        valueOnChange: {},\n        valueDefaultValue: {},\n        controlledToUncontrolled: {},\n        uncontrolledToControlled: {},\n    };\n}\n/** Reset controlled usage warnings for testing purposes. */\nexport function resetControlledWarnings() {\n    if (process.env.NODE_ENV !== 'production') {\n        warningsMap.valueOnChange = {};\n        warningsMap.valueDefaultValue = {};\n        warningsMap.controlledToUncontrolled = {};\n        warningsMap.uncontrolledToControlled = {};\n    }\n}\n/**\n * Check for and warn on the following error conditions with a form component:\n * - A value prop is provided (indicated it's being used as controlled) without a change handler,\n *    and the component is not read-only\n * - Both the value and defaultValue props are provided\n * - The component is attempting to switch between controlled and uncontrolled\n *\n * The messages mimic the warnings React gives for these error conditions on input elements.\n * The warning will only be displayed once per component ID.\n */\nexport function warnControlledUsage(params) {\n    if (process.env.NODE_ENV !== 'production') {\n        var componentId = params.componentId, componentName = params.componentName, defaultValueProp = params.defaultValueProp, props = params.props, oldProps = params.oldProps, onChangeProp = params.onChangeProp, readOnlyProp = params.readOnlyProp, valueProp = params.valueProp;\n        // This warning logic closely follows what React does for native <input> elements.\n        var oldIsControlled = oldProps ? checkIsControlled(oldProps, valueProp) : undefined;\n        var newIsControlled = checkIsControlled(props, valueProp);\n        if (newIsControlled) {\n            // onChange (or readOnly) must be provided if value is provided\n            var hasOnChange = !!props[onChangeProp];\n            var isReadOnly = !!(readOnlyProp && props[readOnlyProp]);\n            if (!(hasOnChange || isReadOnly) && !warningsMap.valueOnChange[componentId]) {\n                warningsMap.valueOnChange[componentId] = true;\n                warn(\"Warning: You provided a '\".concat(String(valueProp), \"' prop to a \").concat(String(componentName), \" without an '\").concat(String(onChangeProp), \"' handler. \") +\n                    \"This will render a read-only field. If the field should be mutable use '\".concat(String(defaultValueProp), \"'. \") +\n                    \"Otherwise, set '\".concat(String(onChangeProp), \"'\").concat(readOnlyProp ? \" or '\".concat(String(readOnlyProp), \"'\") : '', \".\"));\n            }\n            // value and defaultValue are mutually exclusive\n            var defaultValue = props[defaultValueProp];\n            if (defaultValue !== undefined && defaultValue !== null && !warningsMap.valueDefaultValue[componentId]) {\n                warningsMap.valueDefaultValue[componentId] = true;\n                warn(\"Warning: You provided both '\".concat(String(valueProp), \"' and '\").concat(String(defaultValueProp), \"' to a \").concat(componentName, \". \") +\n                    \"Form fields must be either controlled or uncontrolled (specify either the '\".concat(String(valueProp), \"' prop, \") +\n                    \"or the '\".concat(String(defaultValueProp), \"' prop, but not both). Decide between using a controlled or uncontrolled \") +\n                    \"\".concat(componentName, \" and remove one of these props. More info: https://fb.me/react-controlled-components\"));\n            }\n        }\n        // Warn if switching between uncontrolled and controlled. (One difference between this implementation\n        // and React's <input> is that if oldIsControlled is indeterminate and newIsControlled true, we don't warn.)\n        if (oldProps && newIsControlled !== oldIsControlled) {\n            var oldType = oldIsControlled ? 'a controlled' : 'an uncontrolled';\n            var newType = oldIsControlled ? 'uncontrolled' : 'controlled';\n            var warnMap = oldIsControlled ? warningsMap.controlledToUncontrolled : warningsMap.uncontrolledToControlled;\n            if (!warnMap[componentId]) {\n                warnMap[componentId] = true;\n                warn(\"Warning: A component is changing \".concat(oldType, \" \").concat(componentName, \" to be \").concat(newType, \". \") +\n                    \"\".concat(componentName, \"s should not switch from controlled to uncontrolled (or vice versa). \") +\n                    \"Decide between using controlled or uncontrolled for the lifetime of the component. \" +\n                    \"More info: https://fb.me/react-controlled-components\");\n            }\n        }\n    }\n}\n//# sourceMappingURL=warnControlledUsage.js.map","import { warn } from './warn';\n/**\n * Warns when a deprecated props are being used.\n *\n * @public\n * @param componentName - The name of the component being used.\n * @param props - The props passed into the component.\n * @param deprecationMap - The map of deprecations, where key is the prop name and the value is\n * either null or a replacement prop name.\n */\nexport function warnDeprecations(componentName, props, deprecationMap) {\n    if (process.env.NODE_ENV !== 'production') {\n        for (var propName in deprecationMap) {\n            if (props && propName in props) {\n                var deprecationMessage = \"\".concat(componentName, \" property '\").concat(propName, \"' was used but has been deprecated.\");\n                var replacementPropName = deprecationMap[propName];\n                if (replacementPropName) {\n                    deprecationMessage += \" Use '\".concat(replacementPropName, \"' instead.\");\n                }\n                warn(deprecationMessage);\n            }\n        }\n    }\n}\n//# sourceMappingURL=warnDeprecations.js.map","import { warn } from './warn';\n/**\n * Warns when two props which are mutually exclusive are both being used.\n *\n * @public\n * @param componentName - The name of the component being used.\n * @param props - The props passed into the component.\n * @param exclusiveMap - A map where the key is a parameter, and the value is the other parameter.\n */\nexport function warnMutuallyExclusive(componentName, props, exclusiveMap) {\n    if (process.env.NODE_ENV !== 'production') {\n        for (var propName in exclusiveMap) {\n            if (props && props[propName] !== undefined) {\n                var propInExclusiveMapValue = exclusiveMap[propName];\n                if (propInExclusiveMapValue && props[propInExclusiveMapValue] !== undefined) {\n                    warn(\"\".concat(componentName, \" property '\").concat(propName, \"' is mutually exclusive with '\").concat(exclusiveMap[propName], \"'. \") +\n                        \"Use one or the other.\");\n                }\n            }\n        }\n    }\n}\n//# sourceMappingURL=warnMutuallyExclusive.js.map"],"names":["Async","parent","onError","this","_timeoutIds","_immediateIds","_intervalIds","_animationFrameIds","_isDisposed","_parent","_onErrorHandler","_noop","prototype","dispose","id","hasOwnProperty","clearTimeout","parseInt","clearImmediate","clearInterval","cancelAnimationFrame","setTimeout","callback","duration","_this","timeoutId","apply","e","_logError","setImmediate","targetElement","immediateId","win","setInterval","intervalId","throttle","func","wait","options","lastResult","lastArgs","waitMS","leading","trailing","lastExecuteTime","userCall","now","Date","delta","waitLength","args","_i","arguments","length","debounce","noOpFunction","cancel","flush","pending","maxWait","lastCallTime","isNaN","markExecuted","time","invokeFunction","executeImmediately","maxWaitDelta","maxWaitExpired","Math","min","resultFunction","requestAnimationFrame","animationFrameId","animationFrameCallback","SCROLL_GUTTER","AutoScroll","element","theWin","_events","_scrollableParent","_incrementScroll","bind","_scrollRect","document","body","on","_onMouseMove","_onTouchMove","_stopScroll","ev","_computeScrollVelocity","touches","clientX","clientY","scrollRect","clientDirection","scrollClient","scrollRectTop","top","scrollRectLeft","left","scrollClientBottom","height","scrollClientRight","width","_isVerticalScroll","_scrollVelocity","max","_startScroll","_timeoutId","scrollTop","round","scrollLeft","BaseComponent","_super","props","context","call","obj","methodNames","i","len","_makeSafe","_makeAllSafe","componentDidUpdate","prevProps","prevState","_updateComponentRef","componentDidMount","_setComponentRef","componentRef","componentWillUnmount","__disposables","_disposables","disposable","Object","defineProperty","get","__className","results","exec","constructor","toString","enumerable","configurable","__async","push","__events","_resolveRef","refName","__resolves","ref","currentProps","newProps","_warnDeprecations","deprecationMap","className","_warnMutuallyExclusive","mutuallyExclusiveMap","_warnConditionallyRequiredProps","requiredProps","conditionalPropName","condition","value","_skipComponentRefResolution","current","methodName","classMethod","prototypeMethod","retVal","nullRender","DelayedRender","state","isRendered","undefined","delay","window","setState","render","only","children","defaultProps","EventGroup","_id","_uniqueId","_eventRecords","raise","target","eventName","eventArgs","bubbleEvent","doc","theDoc","_isElement","createEvent","initEvent","dispatchEvent","createEventObject","evObj","fireEvent","events","__events__","eventRecords","eventRecordList","listIndex","record","objectCallback","isObserved","isDeclared","declaredEvents","__declaredEvents","stopPropagation","event","cancelBubble","addEventListener","HTMLElement","off","onAll","useCapture","indexOf","split","parent_1","eventRecord","count","processElementEvent","result","preventDefault","elementCallback","attachEvent","targetArrayLookup","targetArray","splice","removeEventListener","detachEvent","declare","performance","FabricPerformance","measure","name","setPeriodicReset","start","end","measurement","summary","totalDuration","all","timeStamp","reset","NaN","GLOBAL_SETTINGS_PROP_NAME","CALLBACK_STATE_PROP_NAME","_counter","GlobalSettings","getValue","key","defaultValue","globalSettings","_getGlobalSettings","setValue","callbacks","oldValue","changeDescription","addChangeListener","cb","__id__","_getCallbacks","String","removeChangeListener","_a","globalObj","KeyCodes","backspace","tab","enter","shift","ctrl","alt","pauseBreak","capslock","escape","space","pageUp","pageDown","home","up","right","down","insert","del","zero","one","two","three","four","five","six","seven","eight","nine","colon","a","b","c","d","f","g","h","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","leftWindow","rightWindow","select","zero_numpad","one_numpad","two_numpad","three_numpad","four_numpad","five_numpad","six_numpad","seven_numpad","eight_numpad","nine_numpad","multiply","add","subtract","decimalPoint","divide","f1","f2","f3","f4","f5","f6","f7","f8","f9","f10","f11","f12","numlock","scrollLock","semicolon","equalSign","comma","dash","period","forwardSlash","graveAccent","openBracket","backSlash","closeBracket","singleQuote","Rectangle","bottom","equals","rect","parseFloat","toFixed","appendFunction","functions","forEach","mergeAriaAttributeValues","ariaAttributes","mergedAttribute","filter","arg","join","trim","findIndex","array","fromIndex","index","find","createArray","size","getItem","toMatrix","items","columnCount","reduce","rows","currentValue","removeIndex","_","replaceElement","newElement","copy","slice","addElementAtIndex","itemToAdd","flatten","item","concat","arraysEqual","array1","array2","_syncModuleCache","WeakMap","asAsync","Component","load","forwardedRef","Placeholder","asyncPlaceholder","rest","then","LoadedComponent","set","onLoad","catch","assertNever","Error","MAX_CACHE_COUNT","DEFAULT_SPECIFICITY_MULTIPLIER","_memoizedClassNames","stylesheet","getInstance","onReset","classNamesFunction","windowMap","Map","styleCalcCount","getClassNamesCount","currentMemoizedClassNames","styleFunctionOrObject","styleProps","useStaticStyles","__noStyleOverride__","shadowConfig","__shadowConfig__","has","theme","rtl","disableCaching","_traverseMap","specificityMultiplier","cacheSize","FabricConfig","enableClassNameCacheFullWarning","console","warn","trace","clear","_traverseEdge","_normalizeValue","inputs","__cachedInputs__","propName","componentAsMemoizer","outer","Outer","inner","Inner","innerMemoizer","defaultRender","innerProps","outerProps","composeComponentAs","isControlled","valueProp","createMergedRef","local","refs","newRefs","resolver","newValue","createResolver","css","classes","args_1","NO_CUSTOMIZATIONS","settings","scopedSettings","inCustomizerContext","_allSettings","Customizations","applySettings","_raiseChange","applyScopedSettings","scopeName","getSettings","properties","localSettings","localScopedSettings","globalScopedSettings","properties_1","property","applyBatchedUpdates","code","suppressUpdate","_suppressUpdates","observe","onChange","unobserve","Customizer","_onCustomizationChange","forceUpdate","contextTransform","Consumer","parentContext","newContext","Provider","CustomizerContext","customizations","useMergeStylesShadowRootContext","MergeStylesShadowRootContext","MergeStylesShadowRootConsumer","stylesheetKey","_b","useMergeStylesHooks","useAdoptedStylesheetEx","useMergeStylesRootStylesheets","useWindow","shadowCtx","rootMergeStyles","memoizedMakeShadowConfig","memoize","mergeComponentStyles","defaultStyles","componentStyles","styles","customizable","scope","fields","concatStyles","ComposedComponent","resultClass","ComponentWithInjectedProps","_styleCache","_onSettingChanged","inShadow","getWindow","componentProps","default","component","mergedStyles","concatStyleSets","merged","displayName","contextType","hoistStatics","mergeCustomizations","mergeSettings","oldSettings","newSettings","mergeSettingsWith","_isSettingsFunction","_settingsMergeWith","mergeScopedSettings","scopedSettingsFromProps","oldScopedSettings","newScopedSettings","_scopedSettingsMergeWith","useCustomizationSettings","useForceUpdate","canUseDOM","createElement","getDocument","rootElement","el","ownerDocument","getFirstVisibleElementFromSelector","selector","elements","querySelectorAll","Array","from","defaultView","getRect","innerWidth","innerHeight","getBoundingClientRect","_window","raiseClick","Event","createNewEvent","setSSR","isEnabled","extendComponent","methods","name_1","IS_FOCUSABLE_ATTRIBUTE","IS_VISIBLE_ATTRIBUTE","FOCUSZONE_ID_ATTRIBUTE","FOCUSZONE_SUB_ATTRIBUTE","getFirstFocusable","currentElement","includeElementsInFocusZones","includeShadowRoots","getNextElement","getLastFocusable","getPreviousElement","getFirstTabbable","checkNode","getLastTabbable","focusFirstChild","bypassHiddenElements","focusAsync","suppressParentTraversal","traverseChildren","allowFocusRoot","tabbable","isCurrentElementVisible","isElementVisible","isElementFocusZone","isElementFocusSubZone","childMatch","lastElementChild","shadowRoot","isElementTabbable","childMatchSiblingMatch","previousElementSibling","childMatchParent","parentElement","childMatchParentMatch","siblingMatch","suppressChildTraversal","isElementVisibleAndNotHidden","firstElementChild","nextElementSibling","getAttribute","visibilityAttribute","offsetHeight","offsetParent","isVisible","hidden","getComputedStyle","visibility","checkTabIndex","checkShadowRoot","disabled","tabIndex","tabIndexAttributeValue","isFocusableAttribute","isTabIndexSet","delegatesFocus","tagName","doesElementContainFocus","currentActiveElement","activeElement","shouldWrapFocus","noWrapDataAttribute","animationId","focus","getFocusableByIndexPath","path","path_1","nextChild","getElementIndexPath","fromElement","toElement","unshift","CURRENT_ID_PROPERTY","DEFAULT_ID_STRING","_global","_initializedStylesheetResets","getId","prefix","resetIds","counter","nativeElementMap","label","audio","video","ol","li","button","input","textarea","option","table","tr","th","td","colGroup","col","form","iframe","img","getNativeElementProps","excludedPropNames","allowedPropNames","getPropsWithDefaults","propsWithoutDefaults","keys","REACT_LIFECYCLE_EXCLUSIONS","hoistMethods","destination","source","exclusions","hoisted","_loop_1","unhoistMethods","dest","isIE11","navigator","userAgent","initializeComponentRef","_onMount","_onUpdate","_onUnmount","initializeFocusRects","disableFocusRects","__hasInitializeFocusRects__","_onMouseDown","_onPointerDown","_onKeyDown","pointerType","which","UNWANTED_ENCLOSURES_REGEX","UNWANTED_CHARS_REGEX","PHONENUMBER_REGEX","MULTIPLE_WHITESPACES_REGEX","UNSUPPORTED_TEXT_REGEX","getInitials","isRtl","allowPhoneInitials","replace","cleanupDisplayName","test","initials","splits","charAt","toUpperCase","getInitialsLatin","DirectionalKeyCodes","isDirectionalKeyCode","addDirectionalKeyCode","_language","STORAGE_KEY","getLanguage","persistenceType","savedLanguage","localStorage","sessionStorage","documentElement","setLanguage","language","persistenceParam","setAttribute","data","setItem","getDistanceBetweenPoints","point1","point2","left1","top1","left2","top2","sqrt","pow","fitContentToBounds","scale","contentSize","boundsSize","mode","maxScale","contentAspectRatio","boundsAspectRatio","finalScale","calculatePrecision","groups","precisionRound","precision","base","exp","_resetCounter","_emptyObject","empty","_dictionary","_weakMap","setMemoizeWeakMap","weakMap","resetMemoizations","_target","_key","descriptor","fn","memoizeFunction","maxCacheSize","ignoreNullOrUndefinedResult","rootNode","localResetCounter","currentNode","_createNode","_normalizeArg","map","createMemoizer","cache","val","merge","_merge","circularReferences","isArray","isCircularReference","pop","isIOS","tagsToIgnore","modalize","targetDocument","affectedNodes","sibling","ariaHidden","toLowerCase","node","originalValue","removeAttribute","unmodalize","shallowCompare","assign","filteredAssign","isAllowed","sourceObject","mapEnumByName","theEnum","Number","values","arr","omit","isMacResult","isMac","hasHorizontalOverflow","clientWidth","scrollWidth","hasVerticalOverflow","clientHeight","scrollHeight","hasOverflow","toObjectMap","items_1","keys_1","baseElementEvents","baseElementProperties","htmlElementProperties","labelProperties","audioProperties","videoProperties","olProperties","liProperties","anchorProperties","buttonProperties","inputProperties","textAreaProperties","selectProperties","optionProperties","tableProperties","trProperties","thProperties","tdProperties","colGroupProperties","colProperties","formProperties","iframeProperties","imgProperties","imageProperties","divProperties","getNativeProps","keys_2","memoizer","composeRenderFunction","_baseUrl","getResourceUrl","url","setBaseUrl","baseUrl","_isRTL","RTL_LOCAL_STORAGE_KEY","getRTL","savedRTL","setRTL","isRTL","persistSetting","getRTLSafeKeyCode","safeRequestAnimationFrame","activeTimeouts","Set","delete","safeSetTimeout","_scrollbarWidth","_bodyScrollDisabledCount","DisabledScrollClassName","overflow","DATA_IS_SCROLLABLE_ATTRIBUTE","allowScrollOnElement","_previousClientY","_element","computedStyles","targetTouches","passive","scrollableParent","findScrollableParent","isColumnReverse","flexDirection","abs","ceil","allowOverscrollOnElement","_disableIosBodyScroll","disableBodyScroll","classList","capture","enableBodyScroll","remove","getScrollbarWidth","scrollDiv","style","setProperty","appendChild","offsetWidth","removeChild","startingElement","overflowY","getPropertyValue","Selection","onSelectionChanged","onItemsChanged","getKey","canSelectItem","_c","selectionMode","multiple","_getKey","defaultGetKey","_changeEventSuppressionCount","_exemptedCount","_anchoredIndex","_unselectableCount","_onSelectionChanged","_onItemsChanged","_canSelectItem","_keyToIndexMap","_isModal","setItems","getSelectedCount","setChangeEvents","suppressChange","_hasChanged","_change","isModal","setModal","setAllSelected","shouldClear","newKeyToIndexMap","newUnselectableIndices","hasSelectionChanged","haveItemsChanged","_setAllSelected","newExemptedIndicies","newExemptedCount","indexProperty","_exemptedIndices","exemptKey","_items","newIndex","_isAllSelected","_unselectableIndices","_selectedItems","_updateCount","getItems","getSelection","isIndexSelected","getSelectedIndices","_selectedIndices","getItemIndex","isRangeSelected","endIndex","isAllSelected","selectableCount","single","isKeySelected","setKeySelected","isSelected","shouldAnchor","setIndexSelected","none","isExempt","setRangeSelected","startIndex","newAnchorIndex","selectToKey","clearSelection","selectToIndex","selectToRange","anchorIndex","toggleAllSelected","toggleKeySelected","toggleIndexSelected","toggleRangeSelected","preserveModalState","SelectionMode","SelectionDirection","SELECTION_CHANGE","SELECTION_ITEMS_CHANGE","IsFocusVisibleClassName","IsFocusHiddenClassName","updateClassList","enabled","setFocusVisibility","registeredProviders","noop","noopShadow","noopRootStylesheets","noopUndefined","MergeStylesDefaultContext","stylesheets","useAdoptedStylesheet","useShadowConfig","useHasMergeStylesShadowRootContext","useStyled","ctx","FORMAT_ARGS_REGEX","FORMAT_REGEX","format","match","replacement","DefaultFields","styled","baseStyles","getProps","pure","Wrapped","customizedStyles","dir","additionalProps","propStyles","concatenatedStyles","pureComponent","mountCounters","callbackMap","setMountCounters","currValue","setCallbackMap","onMouseDown","onPointerDown","onKeyDown","onKeyUp","_onKeyUp","FocusRectsContext","useFocusRects","rootRef","_d","providerRef","FocusRects","message","setWarningCallback","warningCallback","_warningCallback","warnConditionallyRequiredProps","componentName","resetControlledWarnings","warnControlledUsage","params","warnDeprecations","warnMutuallyExclusive","exclusiveMap"],"sourceRoot":""}