{"version":3,"sources":["../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useUnmount.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/StyleOptionsState.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useTarget.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/keyframes.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/usePrevious.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useId.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useOnEvent.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/getVendorSettings.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/transforms/kebabRules.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/transforms/prefixRules.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/transforms/provideUnits.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/transforms/rtlifyRules.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/styleToClassName.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/tokenizeWithParentheses.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useConst.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/concatStyleSets.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/mergeStyleSets.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useBoolean.js","../../../../node_modules/.pnpm/@fluentui+react-focus@8.9.10_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-focus/lib/components/FocusZone/FocusZone.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/concatStyleSetsWithProps.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useControllableValue.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/fontFace.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useSetTimeout.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useRefEffect.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useMergedRefs.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/shadowConfig.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useAsync.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/extractStyleParts.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/mergeStyles.js","../../../../node_modules/.pnpm/@fluentui+merge-styles@8.6.13/node_modules/@fluentui/merge-styles/lib/Stylesheet.js","../../../../node_modules/.pnpm/@fluentui+react-hooks@8.8.16_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-hooks/lib/useWarnings.js","../../../../node_modules/.pnpm/@fluentui+react-focus@8.9.10_@types+react@17.0.69_react@17.0.1/node_modules/@fluentui/react-focus/lib/components/FocusZone/FocusZone.types.js"],"names":["__webpack_require__","d","__webpack_exports__","useUnmount","react__WEBPACK_IMPORTED_MODULE_0__","callback","unmountRef","current","_a","call","setRTL","getStyleOptions","_rtl","_shadowConfig__WEBPACK_IMPORTED_MODULE_0__","isRTL","getRTL","undefined","document","documentElement","getAttribute","rtl","shadowConfig","useTarget","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_0__","react__WEBPACK_IMPORTED_MODULE_1__","_fluentui_react_window_provider__WEBPACK_IMPORTED_MODULE_2__","target","hostElement","_b","_c","previousTargetProp","targetRef","targetWindow","Object","currentElement","getRootNode","host","querySelector","currentDoc","keyframes","_StyleOptionsState__WEBPACK_IMPORTED_MODULE_0__","_Stylesheet__WEBPACK_IMPORTED_MODULE_1__","_styleToClassName__WEBPACK_IMPORTED_MODULE_2__","timeline","stylesheet","getInstance","rulesArray","prop","hasOwnProperty","push","rules","join","className","classNameFromKey","name","getClassName","insertRule","concat","cacheClassName","usePrevious","value","ref","useId","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_1__","prefix","providedId","useOnEvent","element","eventName","useCapture","callbackRef","actualElement","addEventListener","ev","_vendorSettings","kebabRules_rules","kebabRules","rulePairs","index","rule","charAt","replace","toLowerCase","autoPrefixNames","user-select","prefixRules","vendorSettings","doc","nav","navigator","userAgent","isWebkit","style","isMoz","indexOf","isOpera","isMs","test","getVendorSettings","rtlifyRules_a","NON_PIXEL_NUMBER_PROPS","provideUnits","isNonPixelProp","isVariableOrPrefixed","unit","LEFT","RIGHT","NO_FLIP","NAME_REPLACEMENTS","VALUE_REPLACEMENTS","w-resize","sw-resize","nw-resize","rtlifyRules","options","name_1","String","parts","split","length","flipQuad","partIndex","numberVal","parseInt","negateNum","DISPLAY_NAME","globalSelectorRegExp","expandSelector","newSelector","currentSelector","extractSelector","selector","__order","extractRules","selectorWithGlobals","replacementInfo","findGlobal","match","exec","map","v","trim","reverse","reduce","matchIndex","matchEndIndex","replacement","slice","expandCommaSeparatedGlobals","s","forEach","separatedSelector","args","potentialSelector","currentRules","_i","args_1","arg","expandedRules","argsFromClassName","Array","isArray","propValue","selectors","expandQuads","partStart","parens","i","substring","tokenizeWithParentheses","p","repeatString","count","serializeRuleEntries","ruleEntries","allEntries","entry","splice","styleToRegistration","arguments","Stylesheet","key","serialized","hasProps","rulesForSelector","propName","getKeyForRules","registration","rootStyle","displayName","getDisplayName","rulesToInsert","applyRegistration","specificityMultiplier","sheet","processedRule","styleToClassName","apply","tslib_es6","useConst","initialValue","concatStyleSets","tslib__WEBPACK_IMPORTED_MODULE_0__","_shadowConfig__WEBPACK_IMPORTED_MODULE_1__","styleSets","subComponentStyles","mergedSet","workingSubcomponentStyles","styleSets_1","currentSet","currentComponentStyles","subCompProp","mergedValue","currentValue","keys","mergedSubStyles","_loop_1","workingSet_1","styleProps","styleFunctionOrObject","mergeStyleSets","mergeCssSets","_concatStyleSets__WEBPACK_IMPORTED_MODULE_1__","_extractStyleParts__WEBPACK_IMPORTED_MODULE_2__","_StyleOptionsState__WEBPACK_IMPORTED_MODULE_3__","_styleToClassName__WEBPACK_IMPORTED_MODULE_4__","_shadowConfig__WEBPACK_IMPORTED_MODULE_5__","_Stylesheet__WEBPACK_IMPORTED_MODULE_6__","styleSet","classNameSet","opts","concatenatedStyleSet","registrations","styleSetArea","styles","classes","objects","registrations_1","useBoolean","_useConst__WEBPACK_IMPORTED_MODULE_1__","initialState","setValue","setTrue","setFalse","toggle","FocusZone","focusZoneStyles","_FocusZone_types__WEBPACK_IMPORTED_MODULE_2__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_3__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_4__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_5__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_6__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_7__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_8__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_9__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_10__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_11__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_12__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_13__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_14__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_15__","_fluentui_utilities__WEBPACK_IMPORTED_MODULE_16__","_fluentui_merge_styles__WEBPACK_IMPORTED_MODULE_17__","_fluentui_style_utilities__WEBPACK_IMPORTED_MODULE_18__","NO_VERTICAL_WRAP","NO_HORIZONTAL_WRAP","LARGE_DISTANCE_FROM_CENTER","LARGE_NEGATIVE_DISTANCE_FROM_CENTER","focusZoneClass","raiseClickFromKeyboardEvent","event","MouseEvent","ctrlKey","metaKey","shiftKey","altKey","bubbles","cancelable","createEvent","initMouseEvent","window","dispatchEvent","_allInstances","_outerZones","Set","ALLOWED_INPUT_TYPES","ALLOW_VIRTUAL_ELEMENTS","_super","props","_d","_this","this","_root","_mergedRef","_onFocus","_portalContainsElement","newActiveElement","onActiveElementChanged","doNotAllowFocusEventToPropagate","stopFocusPropagation","onFocusNotification","onFocus","shouldFocusInnerElementWhenReceivedFocus","defaultTabbableElement","isImmediateDescendant","_isImmediateDescendantOfZone","parentElement","_inShadowRoot","maybeElementToFocus","focus","_activeElement","initialElementFocused","_setFocusAlignment","_updateTabIndexes","stopPropagation","_onBlur","_setParkedFocus","_onMouseDown","disabled","path","pop","_setActiveElement","_onKeyDown","theme","direction","isInnerZoneKeystroke","pagingSupportDisabled","shouldEnterInnerZone","onKeyDown","isDefaultPrevented","_getDocument","activeElement","_isInnerZone","innerZone","_getFirstInnerZone","focusElement","firstChild","which","space","_shouldRaiseClicksOnSpace","_tryInvokeClickForFocusable","left","vertical","_preventDefaultWhenHandled","_moveFocusLeft","right","_moveFocusRight","up","horizontal","_moveFocusUp","down","_moveFocusDown","pageDown","_moveFocusPaging","pageUp","tab","allowTabKey","handleTabKey","all","inputOnly","_isElementInput","focusChanged","_processingTabKey","_shouldWrapFocus","shouldResetActiveElementWhenTabFromZone","home","_isContentEditableElement","_shouldInputLoseFocus","end","lastChild","enter","_shouldRaiseClicksOnEnter","preventDefault","_getHorizontalDistanceFromCenter","isForward","activeRect","targetRect","leftAlignment","_focusAlignment","x","targetRectTop","Math","floor","top","activeRectBottom","bottom","targetRectBottom","activeRectTop","width","abs","_id","shouldRaiseClicksFallback","shouldRaiseClicks","defaultProps","shouldRaiseClicksOnEnter","shouldRaiseClicksOnSpace","getOuterZones","size","_onKeyDownCapture","zone","prototype","componentDidMount","root","context","shadowRoot","body","nodeType","add","defaultActiveElement","shouldFocusOnMount","componentDidUpdate","_defaultFocusElement","preventFocusRestoration","_lastIndexPath","elementToFocus","componentWillUnmount","delete","removeEventListener","render","tag","as","elementType","rootProps","ariaDescribedBy","ariaLabelledBy","divProps","Tag","_evaluateFocusBeforeRender","aria-labelledby","aria-describedby",":focus","outline","elementRef","data-focuszone-id","onMouseDownCapture","children","forceIntoFirstElement","bypassHiddenElements","ownerZoneElement","_getOwnerZone","ownerZone","focusLast","forceAlignment","onBeforeFocus","shouldReceiveFocus","setFocusAlignment","point","defineProperty","get","enumerable","configurable","focusedElement","shouldRestoreFocus","isParked","_isParked","allowFocusRoot","_parkedTabIndex","setAttribute","removeAttribute","previousActiveElement","tabIndex","preventDefaultWhenHandled","targetElement","tagName","rootElement","child","firstElementChild","nextElementSibling","_moveFocus","getDistanceFromCenter","useDefaultWrap","candidateDistance","candidateElement","changedFocus","isBidirectional","bidirectional","getBoundingClientRect","elementDistance","isCircularNavigation","lastElementChild","targetTop","distance","shouldWrap","parseFloat","toFixed","scrollableParent","targetBottom","pagesize","clientHeight","isHorizontal","isVertical","rect","top_1","height","childNodes","childIndex","type","selectionStart","isRangeSelected","selectionEnd","inputValue","isReadonly","readOnly","shouldInputLoseFocusOnArrowKey","noWrapDataAttribute","checkForNoWrap","contextType","data-tabster","concatStyleSetsWithProps","_concatStyleSets__WEBPACK_IMPORTED_MODULE_0__","allStyles","result","allStyles_1","useControllableValue","controlledValue","defaultUncontrolledValue","onChange","isControlled","valueRef","onChangeRef","setValueOrCallOnChange","update","newValue","fontFace","font","useSetTimeout","timeoutIds","id","clearTimeout","setTimeout","func","duration","useRefEffect","initial","data","refCallback","cleanup","createRefCallback","useMergedRefs","refs","mergedCallback","refs_1","GLOBAL_STYLESHEET_KEY","SHADOW_DOM_STYLESHEET_SETTING","DEFAULT_SHADOW_CONFIG","makeShadowConfig","isShadowConfig","stylesheetKey","inShadow","__isShadowConfig__","isRecord","useAsync","asyncRef","dispose","extractStyleParts","_processArgs","argsList","argsList_1","translatedArgs","mergeStyles","mergeCss","_extractStyleParts__WEBPACK_IMPORTED_MODULE_0__","_StyleOptionsState__WEBPACK_IMPORTED_MODULE_2__","_Stylesheet__WEBPACK_IMPORTED_MODULE_3__","styleArgs","InjectionMode","_stylesheet","none","insertNode","appendChild","REUSE_STYLE_NODE","_global","config","serializedStylesheet","_e","_f","_rules","_preservedRules","_counter","_keyToClassName","_onInsertRuleCallbacks","_onResetCallbacks","_classNameToArgs","_config","injectionMode","defaultPrefix","namespace","cspSettings","classNameToArgs","counter","classNameCache","keyToClassName","preservedRules","_lastStyleElement","ownerDocument","fabricConfig","FabricConfig","serialize","JSON","stringify","setConfig","onReset","filter","cb","onInsertRule","_getCacheKey","getClassNameCache","insertedRulesFromClassName","preserve","_getStyleElement","_insertRuleIntoSheet","createTextNode","getRules","includePreservedRules","reset","resetKeys","_createStyleElement","head","styleElement","createElement","nodeToInsertBefore","nonce","placeholderStyleTag","_findPlaceholderStyleTag","insertBefore","contains","cssRules","e","_styleElement","requestAnimationFrame","useWarnings","FocusZoneTabbableElements","FocusZoneDirection"],"mappings":"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","file":"static/js/vendor.initial~5640d0c1.60c7164b.chunk.js","sourcesContent":["import * as React from 'react';\n/**\n * Hook which synchronously executes a callback when the component is about to unmount.\n *\n * @param callback - Function to call during unmount.\n */\nexport var useUnmount = function (callback) {\n    var unmountRef = React.useRef(callback);\n    unmountRef.current = callback;\n    React.useEffect(function () { return function () {\n        var _a;\n        (_a = unmountRef.current) === null || _a === void 0 ? void 0 : _a.call(unmountRef);\n    }; }, []);\n};\n//# sourceMappingURL=useUnmount.js.map","import { DEFAULT_SHADOW_CONFIG } from './shadowConfig';\n/**\n * Sets the current RTL value.\n */\nexport function setRTL(isRTL) {\n    if (_rtl !== isRTL) {\n        _rtl = isRTL;\n    }\n}\n/**\n * Gets the current RTL value.\n */\nexport function getRTL() {\n    if (_rtl === undefined) {\n        _rtl =\n            // eslint-disable-next-line no-restricted-globals\n            typeof document !== 'undefined' &&\n                // eslint-disable-next-line no-restricted-globals\n                !!document.documentElement &&\n                // eslint-disable-next-line no-restricted-globals\n                document.documentElement.getAttribute('dir') === 'rtl';\n    }\n    return _rtl;\n}\n// This has been split into 2 lines because it was working in Fabric due to the code being transpiled to es5, so this\n// was converted to var while not working in Fluent that uses babel to transpile the code to be es6-like. Splitting the\n// logic into two lines, however, allows it to work in both scenarios.\nvar _rtl;\n_rtl = getRTL();\nexport function getStyleOptions() {\n    return {\n        rtl: getRTL(),\n        shadowConfig: DEFAULT_SHADOW_CONFIG,\n    };\n}\n//# sourceMappingURL=StyleOptionsState.js.map","import { getDocument } from '@fluentui/utilities';\nimport * as React from 'react';\nimport { useWindow } from '@fluentui/react-window-provider';\n/**\n * Hook to calculate and cache the target element specified by the given target attribute,\n * as well as the target element's (or host element's) parent window\n * @param target- Target selector passed to the component as a property, describing the element that\n * the callout should target\n * @param hostElement- The callout's host element, used for determining the parent window.\n */\nexport function useTarget(target, hostElement) {\n    var _a, _b, _c;\n    var previousTargetProp = React.useRef();\n    var targetRef = React.useRef(null);\n    /**\n     * Stores an instance of Window, used to check\n     * for server side rendering and if focus was lost.\n     */\n    var targetWindow = useWindow();\n    // If the target element changed, find the new one. If we are tracking\n    // target with class name, always find element because we do not know if\n    // fabric has rendered a new element and disposed the old element.\n    if (!target || target !== previousTargetProp.current || typeof target === 'string') {\n        var currentElement = hostElement === null || hostElement === void 0 ? void 0 : hostElement.current;\n        if (target) {\n            if (typeof target === 'string') {\n                // If element is part of shadow dom, then querySelector on shadow root, else query on document\n                if ((_a = currentElement === null || currentElement === void 0 ? void 0 : currentElement.getRootNode()) === null || _a === void 0 ? void 0 : _a.host) {\n                    targetRef.current = (_c = (_b = currentElement === null || currentElement === void 0 ? void 0 : currentElement.getRootNode()) === null || _b === void 0 ? void 0 : _b.querySelector(target)) !== null && _c !== void 0 ? _c : null;\n                }\n                else {\n                    var currentDoc = getDocument(currentElement);\n                    targetRef.current = currentDoc ? currentDoc.querySelector(target) : null;\n                }\n            }\n            else if ('stopPropagation' in target) {\n                targetRef.current = target;\n            }\n            else if ('getBoundingClientRect' in target) {\n                targetRef.current = target;\n            }\n            else if ('current' in target) {\n                targetRef.current = target.current;\n            }\n            else {\n                targetRef.current = target;\n            }\n        }\n        previousTargetProp.current = target;\n    }\n    return [targetRef, targetWindow];\n}\n//# sourceMappingURL=useTarget.js.map","import { getStyleOptions } from './StyleOptionsState';\nimport { Stylesheet } from './Stylesheet';\nimport { serializeRuleEntries } from './styleToClassName';\n/**\n * Registers keyframe definitions.\n *\n * @public\n */\nexport function keyframes(timeline) {\n    var stylesheet = Stylesheet.getInstance();\n    var rulesArray = [];\n    for (var prop in timeline) {\n        if (timeline.hasOwnProperty(prop)) {\n            rulesArray.push(prop, '{', serializeRuleEntries(getStyleOptions(), timeline[prop]), '}');\n        }\n    }\n    var rules = rulesArray.join('');\n    var className = stylesheet.classNameFromKey(rules);\n    if (className) {\n        return className;\n    }\n    var name = stylesheet.getClassName();\n    stylesheet.insertRule(\"@keyframes \".concat(name, \"{\").concat(rules, \"}\"), true);\n    stylesheet.cacheClassName(name, rules, [], ['keyframes', rules]);\n    return name;\n}\n//# sourceMappingURL=keyframes.js.map","import { useRef, useEffect } from 'react';\n/**\n * Hook keeping track of a given value from a previous execution of the component the Hook is used in.\n *\n * See [React Hooks FAQ](https://reactjs.org/docs/hooks-faq.html#how-to-get-the-previous-props-or-state)\n */\nexport function usePrevious(value) {\n    var ref = useRef();\n    useEffect(function () {\n        ref.current = value;\n    });\n    return ref.current;\n}\n//# sourceMappingURL=usePrevious.js.map","import * as React from 'react';\nimport { getId } from '@fluentui/utilities';\n/**\n * Hook to generate a unique ID in the global scope (spanning across duplicate copies of the same library).\n *\n * @param prefix - Optional prefix for the ID\n * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,\n *  without conditioning the hook call\n * @returns The ID\n */\nexport function useId(prefix, providedId) {\n    // getId should only be called once since it updates the global constant for the next ID value.\n    // (While an extra update isn't likely to cause problems in practice, it's better to avoid it.)\n    var ref = React.useRef(providedId);\n    if (!ref.current) {\n        ref.current = getId(prefix);\n    }\n    return ref.current;\n}\n//# sourceMappingURL=useId.js.map","import { on } from '@fluentui/utilities';\nimport * as React from 'react';\n/**\n * Hook to attach an event handler on mount and handle cleanup.\n * @param element - Element (or ref to an element) to attach the event handler to\n * @param eventName - The event to attach a handler for\n * @param callback - The handler for the event\n * @param useCapture - Whether or not to attach the handler for the capture phase\n */\nexport function useOnEvent(element, eventName, callback, useCapture) {\n    // Use a ref for the callback to prevent repeatedly attaching/unattaching callbacks that are unstable across renders\n    var callbackRef = React.useRef(callback);\n    callbackRef.current = callback;\n    React.useEffect(function () {\n        var actualElement = element && 'current' in element ? element.current : element;\n        if (!actualElement || !actualElement.addEventListener) {\n            return;\n        }\n        var dispose = on(actualElement, eventName, function (ev) { return callbackRef.current(ev); }, useCapture);\n        return dispose;\n    }, [element, eventName, useCapture]);\n}\n//# sourceMappingURL=useOnEvent.js.map","var _vendorSettings;\nexport function getVendorSettings() {\n    var _a;\n    if (!_vendorSettings) {\n        // eslint-disable-next-line no-restricted-globals\n        var doc = typeof document !== 'undefined' ? document : undefined;\n        var nav = typeof navigator !== 'undefined' ? navigator : undefined;\n        var userAgent = (_a = nav === null || nav === void 0 ? void 0 : nav.userAgent) === null || _a === void 0 ? void 0 : _a.toLowerCase();\n        if (!doc) {\n            _vendorSettings = {\n                isWebkit: true,\n                isMoz: true,\n                isOpera: true,\n                isMs: true,\n            };\n        }\n        else {\n            _vendorSettings = {\n                isWebkit: !!(doc && 'WebkitAppearance' in doc.documentElement.style),\n                isMoz: !!(userAgent && userAgent.indexOf('firefox') > -1),\n                isOpera: !!(userAgent && userAgent.indexOf('opera') > -1),\n                isMs: !!(nav && (/rv:11.0/i.test(nav.userAgent) || /Edge\\/\\d./i.test(navigator.userAgent))),\n            };\n        }\n    }\n    return _vendorSettings;\n}\n/**\n * Sets the vendor settings for prefixing and vendor specific operations.\n */\nexport function setVendorSettings(vendorSettings) {\n    _vendorSettings = vendorSettings;\n}\n//# sourceMappingURL=getVendorSettings.js.map","var rules = {};\nexport function kebabRules(rulePairs, index) {\n    var rule = rulePairs[index];\n    if (rule.charAt(0) !== '-') {\n        rulePairs[index] = rules[rule] = rules[rule] || rule.replace(/([A-Z])/g, '-$1').toLowerCase();\n    }\n}\n//# sourceMappingURL=kebabRules.js.map","import { getVendorSettings } from '../getVendorSettings';\nvar autoPrefixNames = {\n    'user-select': 1,\n};\nexport function prefixRules(rulePairs, index) {\n    var vendorSettings = getVendorSettings();\n    var name = rulePairs[index];\n    if (autoPrefixNames[name]) {\n        var value = rulePairs[index + 1];\n        if (autoPrefixNames[name]) {\n            if (vendorSettings.isWebkit) {\n                rulePairs.push('-webkit-' + name, value);\n            }\n            if (vendorSettings.isMoz) {\n                rulePairs.push('-moz-' + name, value);\n            }\n            if (vendorSettings.isMs) {\n                rulePairs.push('-ms-' + name, value);\n            }\n            if (vendorSettings.isOpera) {\n                rulePairs.push('-o-' + name, value);\n            }\n        }\n    }\n}\n//# sourceMappingURL=prefixRules.js.map","var NON_PIXEL_NUMBER_PROPS = [\n    'column-count',\n    'font-weight',\n    'flex',\n    'flex-grow',\n    'flex-shrink',\n    'fill-opacity',\n    'opacity',\n    'order',\n    'z-index',\n    'zoom',\n];\nexport function provideUnits(rulePairs, index) {\n    var name = rulePairs[index];\n    var value = rulePairs[index + 1];\n    if (typeof value === 'number') {\n        var isNonPixelProp = NON_PIXEL_NUMBER_PROPS.indexOf(name) > -1;\n        var isVariableOrPrefixed = name.indexOf('--') > -1;\n        var unit = isNonPixelProp || isVariableOrPrefixed ? '' : 'px';\n        rulePairs[index + 1] = \"\".concat(value).concat(unit);\n    }\n}\n//# sourceMappingURL=provideUnits.js.map","var _a;\nvar LEFT = 'left';\nvar RIGHT = 'right';\nvar NO_FLIP = '@noflip';\nvar NAME_REPLACEMENTS = (_a = {},\n    _a[LEFT] = RIGHT,\n    _a[RIGHT] = LEFT,\n    _a);\nvar VALUE_REPLACEMENTS = {\n    'w-resize': 'e-resize',\n    'sw-resize': 'se-resize',\n    'nw-resize': 'ne-resize',\n};\n/**\n * RTLifies the rulePair in the array at the current index. This mutates the array for performance\n * reasons.\n */\nexport function rtlifyRules(options, rulePairs, index) {\n    if (options.rtl) {\n        var name_1 = rulePairs[index];\n        if (!name_1) {\n            return;\n        }\n        var value = rulePairs[index + 1];\n        if (typeof value === 'string' && value.indexOf(NO_FLIP) >= 0) {\n            rulePairs[index + 1] = value.replace(/\\s*(?:\\/\\*\\s*)?\\@noflip\\b(?:\\s*\\*\\/)?\\s*?/g, '');\n        }\n        else if (name_1.indexOf(LEFT) >= 0) {\n            rulePairs[index] = name_1.replace(LEFT, RIGHT);\n        }\n        else if (name_1.indexOf(RIGHT) >= 0) {\n            rulePairs[index] = name_1.replace(RIGHT, LEFT);\n        }\n        else if (String(value).indexOf(LEFT) >= 0) {\n            rulePairs[index + 1] = value.replace(LEFT, RIGHT);\n        }\n        else if (String(value).indexOf(RIGHT) >= 0) {\n            rulePairs[index + 1] = value.replace(RIGHT, LEFT);\n        }\n        else if (NAME_REPLACEMENTS[name_1]) {\n            rulePairs[index] = NAME_REPLACEMENTS[name_1];\n        }\n        else if (VALUE_REPLACEMENTS[value]) {\n            rulePairs[index + 1] = VALUE_REPLACEMENTS[value];\n        }\n        else {\n            switch (name_1) {\n                case 'margin':\n                case 'padding':\n                    rulePairs[index + 1] = flipQuad(value);\n                    break;\n                case 'box-shadow':\n                    rulePairs[index + 1] = negateNum(value, 0);\n                    break;\n            }\n        }\n    }\n}\n/**\n * Given a string value in a space delimited format (e.g. \"1 2 3 4\"), negates a particular value.\n */\nfunction negateNum(value, partIndex) {\n    var parts = value.split(' ');\n    var numberVal = parseInt(parts[partIndex], 10);\n    parts[0] = parts[0].replace(String(numberVal), String(numberVal * -1));\n    return parts.join(' ');\n}\n/**\n * Given a string quad, flips the left and right values.\n */\nfunction flipQuad(value) {\n    if (typeof value === 'string') {\n        var parts = value.split(' ');\n        if (parts.length === 4) {\n            return \"\".concat(parts[0], \" \").concat(parts[3], \" \").concat(parts[2], \" \").concat(parts[1]);\n        }\n    }\n    return value;\n}\n//# sourceMappingURL=rtlifyRules.js.map","import { __spreadArray } from \"tslib\";\nimport { Stylesheet } from './Stylesheet';\nimport { kebabRules } from './transforms/kebabRules';\nimport { prefixRules } from './transforms/prefixRules';\nimport { provideUnits } from './transforms/provideUnits';\nimport { rtlifyRules } from './transforms/rtlifyRules';\nimport { tokenizeWithParentheses } from './tokenizeWithParentheses';\nvar DISPLAY_NAME = 'displayName';\nfunction getDisplayName(rules) {\n    var rootStyle = rules && rules['&'];\n    return rootStyle ? rootStyle.displayName : undefined;\n}\nvar globalSelectorRegExp = /\\:global\\((.+?)\\)/g;\n/**\n * Finds comma separated selectors in a :global() e.g. \":global(.class1, .class2, .class3)\"\n * and wraps them each in their own global \":global(.class1), :global(.class2), :global(.class3)\"\n *\n * @param selectorWithGlobals The selector to process\n * @returns The updated selector\n */\nfunction expandCommaSeparatedGlobals(selectorWithGlobals) {\n    // We the selector does not have a :global() we can shortcut\n    if (!globalSelectorRegExp.test(selectorWithGlobals)) {\n        return selectorWithGlobals;\n    }\n    var replacementInfo = [];\n    var findGlobal = /\\:global\\((.+?)\\)/g;\n    var match = null;\n    // Create a result list for global selectors so we can replace them.\n    while ((match = findGlobal.exec(selectorWithGlobals))) {\n        // Only if the found selector is a comma separated list we'll process it.\n        if (match[1].indexOf(',') > -1) {\n            replacementInfo.push([\n                match.index,\n                match.index + match[0].length,\n                // Wrap each of the found selectors in :global()\n                match[1]\n                    .split(',')\n                    .map(function (v) { return \":global(\".concat(v.trim(), \")\"); })\n                    .join(', '),\n            ]);\n        }\n    }\n    // Replace the found selectors with their wrapped variants in reverse order\n    return replacementInfo\n        .reverse()\n        .reduce(function (selector, _a) {\n        var matchIndex = _a[0], matchEndIndex = _a[1], replacement = _a[2];\n        var prefix = selector.slice(0, matchIndex);\n        var suffix = selector.slice(matchEndIndex);\n        return prefix + replacement + suffix;\n    }, selectorWithGlobals);\n}\nfunction isSelector(potentialSelector) {\n    return potentialSelector.indexOf(':global(') >= 0 || potentialSelector.indexOf(':') === 0;\n}\nfunction expandSelector(newSelector, currentSelector) {\n    if (newSelector.indexOf(':global(') >= 0) {\n        return newSelector.replace(globalSelectorRegExp, '$1');\n    }\n    else if (newSelector.indexOf(':host(') === 0) {\n        return newSelector;\n    }\n    else if (newSelector.indexOf(':') === 0) {\n        return currentSelector + newSelector;\n    }\n    else if (newSelector.indexOf('&') < 0) {\n        return currentSelector + ' ' + newSelector;\n    }\n    return newSelector;\n}\nfunction extractSelector(currentSelector, rules, selector, value, stylesheet) {\n    if (rules === void 0) { rules = { __order: [] }; }\n    if (selector.indexOf('@') === 0) {\n        selector = selector + '{' + currentSelector;\n        extractRules([value], rules, selector, stylesheet);\n    }\n    else if (selector.indexOf(',') > -1) {\n        expandCommaSeparatedGlobals(selector)\n            .split(',')\n            .map(function (s) { return s.trim(); })\n            .forEach(function (separatedSelector) {\n            return extractRules([value], rules, expandSelector(separatedSelector, currentSelector), stylesheet);\n        });\n    }\n    else {\n        extractRules([value], rules, expandSelector(selector, currentSelector), stylesheet);\n    }\n}\nfunction extractRules(args, rules, currentSelector, stylesheet) {\n    if (rules === void 0) { rules = { __order: [] }; }\n    if (currentSelector === void 0) { currentSelector = '&'; }\n    var currentRules = rules[currentSelector];\n    if (!currentRules) {\n        currentRules = {};\n        rules[currentSelector] = currentRules;\n        rules.__order.push(currentSelector);\n    }\n    for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {\n        var arg = args_1[_i];\n        // If the arg is a string, we need to look up the class map and merge.\n        if (typeof arg === 'string') {\n            var expandedRules = stylesheet.argsFromClassName(arg);\n            if (expandedRules) {\n                extractRules(expandedRules, rules, currentSelector, stylesheet);\n            }\n            // Else if the arg is an array, we need to recurse in.\n        }\n        else if (Array.isArray(arg)) {\n            extractRules(arg, rules, currentSelector, stylesheet);\n        }\n        else {\n            for (var prop in arg) {\n                if (arg.hasOwnProperty(prop)) {\n                    var propValue = arg[prop];\n                    if (prop === 'selectors') {\n                        // every child is a selector.\n                        var selectors = arg.selectors;\n                        for (var newSelector in selectors) {\n                            if (selectors.hasOwnProperty(newSelector)) {\n                                extractSelector(currentSelector, rules, newSelector, selectors[newSelector], stylesheet);\n                            }\n                        }\n                    }\n                    else if (typeof propValue === 'object' || isSelector(prop)) {\n                        // prop is a selector.\n                        if (propValue !== null && propValue !== undefined) {\n                            extractSelector(currentSelector, rules, prop, propValue, stylesheet);\n                        }\n                    }\n                    else {\n                        if (propValue !== undefined) {\n                            // Else, add the rule to the currentSelector.\n                            if (prop === 'margin' || prop === 'padding') {\n                                expandQuads(currentRules, prop, propValue);\n                            }\n                            else {\n                                currentRules[prop] = propValue;\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n    return rules;\n}\nfunction expandQuads(currentRules, name, value) {\n    var parts = typeof value === 'string' ? tokenizeWithParentheses(value) : [value];\n    if (parts.length === 0) {\n        parts.push(value);\n    }\n    if (parts[parts.length - 1] === '!important') {\n        // Remove !important from parts, and append it to each part individually\n        parts = parts.slice(0, -1).map(function (p) { return p + ' !important'; });\n    }\n    currentRules[name + 'Top'] = parts[0];\n    currentRules[name + 'Right'] = parts[1] || parts[0];\n    currentRules[name + 'Bottom'] = parts[2] || parts[0];\n    currentRules[name + 'Left'] = parts[3] || parts[1] || parts[0];\n}\nfunction getKeyForRules(options, rules) {\n    var serialized = [options.rtl ? 'rtl' : 'ltr'];\n    var hasProps = false;\n    for (var _i = 0, _a = rules.__order; _i < _a.length; _i++) {\n        var selector = _a[_i];\n        serialized.push(selector);\n        var rulesForSelector = rules[selector];\n        for (var propName in rulesForSelector) {\n            if (rulesForSelector.hasOwnProperty(propName) && rulesForSelector[propName] !== undefined) {\n                hasProps = true;\n                serialized.push(propName, rulesForSelector[propName]);\n            }\n        }\n    }\n    return hasProps ? serialized.join('') : undefined;\n}\nfunction repeatString(target, count) {\n    if (count <= 0) {\n        return '';\n    }\n    if (count === 1) {\n        return target;\n    }\n    return target + repeatString(target, count - 1);\n}\nexport function serializeRuleEntries(options, ruleEntries) {\n    if (!ruleEntries) {\n        return '';\n    }\n    var allEntries = [];\n    for (var entry in ruleEntries) {\n        if (ruleEntries.hasOwnProperty(entry) && entry !== DISPLAY_NAME && ruleEntries[entry] !== undefined) {\n            allEntries.push(entry, ruleEntries[entry]);\n        }\n    }\n    // Apply transforms.\n    for (var i = 0; i < allEntries.length; i += 2) {\n        kebabRules(allEntries, i);\n        provideUnits(allEntries, i);\n        rtlifyRules(options, allEntries, i);\n        prefixRules(allEntries, i);\n    }\n    // Apply punctuation.\n    for (var i = 1; i < allEntries.length; i += 4) {\n        allEntries.splice(i, 1, ':', allEntries[i], ';');\n    }\n    return allEntries.join('');\n}\nexport function styleToRegistration(options) {\n    var _a;\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var stylesheet = (_a = options.stylesheet) !== null && _a !== void 0 ? _a : Stylesheet.getInstance(options.shadowConfig);\n    var rules = extractRules(args, undefined, undefined, stylesheet);\n    var key = getKeyForRules(options, rules);\n    if (key) {\n        var registration = {\n            className: stylesheet.classNameFromKey(key),\n            key: key,\n            args: args,\n        };\n        if (!registration.className) {\n            registration.className = stylesheet.getClassName(getDisplayName(rules));\n            var rulesToInsert = [];\n            for (var _b = 0, _c = rules.__order; _b < _c.length; _b++) {\n                var selector = _c[_b];\n                rulesToInsert.push(selector, serializeRuleEntries(options, rules[selector]));\n            }\n            registration.rulesToInsert = rulesToInsert;\n        }\n        return registration;\n    }\n    return undefined;\n}\n/**\n * Insert style to stylesheet.\n * @param registration Style registration.\n * @param specificityMultiplier Number of times classname selector is repeated in the css rule.\n * This is to increase css specificity in case it's needed. Default to 1.\n */\nexport function applyRegistration(registration, specificityMultiplier, shadowConfig, sheet) {\n    if (specificityMultiplier === void 0) { specificityMultiplier = 1; }\n    var stylesheet = sheet !== null && sheet !== void 0 ? sheet : Stylesheet.getInstance(shadowConfig);\n    var className = registration.className, key = registration.key, args = registration.args, rulesToInsert = registration.rulesToInsert;\n    if (rulesToInsert) {\n        // rulesToInsert is an ordered array of selector/rule pairs.\n        for (var i = 0; i < rulesToInsert.length; i += 2) {\n            var rules = rulesToInsert[i + 1];\n            if (rules) {\n                var selector = rulesToInsert[i];\n                selector = selector.replace(/&/g, repeatString(\".\".concat(registration.className), specificityMultiplier));\n                // Insert. Note if a media query, we must close the query with a final bracket.\n                var processedRule = \"\".concat(selector, \"{\").concat(rules, \"}\").concat(selector.indexOf('@') === 0 ? '}' : '');\n                stylesheet.insertRule(processedRule);\n            }\n        }\n        stylesheet.cacheClassName(className, key, args, rulesToInsert);\n    }\n}\nexport function styleToClassName(options) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var registration = styleToRegistration.apply(void 0, __spreadArray([options], args, false));\n    if (registration) {\n        applyRegistration(registration, options.specificityMultiplier, options.shadowConfig, options.stylesheet);\n        return registration.className;\n    }\n    return '';\n}\n//# sourceMappingURL=styleToClassName.js.map","/**\n * Split a string into tokens separated by whitespace, except all text within parentheses\n * is treated as a single token (whitespace is ignored within parentheses).\n *\n * Unlike String.split(' '), multiple consecutive space characters are collapsed and\n * removed from the returned array (including leading and trailing spaces).\n *\n * For example:\n * `tokenizeWithParentheses(\"3px calc(var(--x) / 2) 9px    0 \")`\n *   => `[\"3px\", \"calc(var(--x) / 2)\", \"9px\", \"0\"]`\n *\n * @returns The array of tokens. Returns an empty array if the string was empty or contained only whitespace.\n */\nexport function tokenizeWithParentheses(value) {\n    var parts = [];\n    var partStart = 0;\n    var parens = 0;\n    for (var i = 0; i < value.length; i++) {\n        switch (value[i]) {\n            case '(':\n                parens++;\n                break;\n            case ')':\n                if (parens) {\n                    parens--;\n                }\n                break;\n            case '\\t':\n            case ' ':\n                if (!parens) {\n                    // Add the new part if it's not an empty string\n                    if (i > partStart) {\n                        parts.push(value.substring(partStart, i));\n                    }\n                    partStart = i + 1;\n                }\n                break;\n        }\n    }\n    // Add the last part\n    if (partStart < value.length) {\n        parts.push(value.substring(partStart));\n    }\n    return parts;\n}\n//# sourceMappingURL=tokenizeWithParentheses.js.map","import * as React from 'react';\n/**\n * Hook to initialize and return a constant value. Unlike `React.useMemo`, this is guaranteed to\n * always return the same value (and if the initializer is a function, only call it once).\n * This is similar to setting a private member in a class constructor.\n *\n * If the value should ever change based on dependencies, use `React.useMemo` instead.\n *\n * @param initialValue - Initial value, or function to get the initial value. Similar to `useState`,\n * only the value/function passed in the first time this is called is respected.\n * @returns The value. The identity of this value will always be the same.\n */\nexport function useConst(initialValue) {\n    // Use useRef to store the value because it's the least expensive built-in hook that works here\n    // (we could also use `const [value] = React.useState(initialValue)` but that's more expensive\n    // internally due to reducer handling which we don't need)\n    var ref = React.useRef();\n    if (ref.current === undefined) {\n        // Box the value in an object so we can tell if it's initialized even if the initializer\n        // returns/is undefined\n        ref.current = {\n            value: typeof initialValue === 'function' ? initialValue() : initialValue,\n        };\n    }\n    return ref.current.value;\n}\n//# sourceMappingURL=useConst.js.map","import { __spreadArray } from \"tslib\";\nimport { isShadowConfig } from './shadowConfig';\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSets - One or more stylesets to be merged (each param can also be falsy).\n */\nexport function concatStyleSets() {\n    var styleSets = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        styleSets[_i] = arguments[_i];\n    }\n    if (styleSets &&\n        styleSets.length === 1 &&\n        styleSets[0] &&\n        !styleSets[0].subComponentStyles &&\n        !isShadowConfig(styleSets[0])) {\n        return styleSets[0];\n    }\n    var mergedSet = {};\n    // We process sub component styles in two phases. First we collect them, then we combine them into 1 style function.\n    var workingSubcomponentStyles = {};\n    for (var _a = 0, styleSets_1 = styleSets; _a < styleSets_1.length; _a++) {\n        var currentSet = styleSets_1[_a];\n        if (currentSet && !isShadowConfig(currentSet)) {\n            for (var prop in currentSet) {\n                if (currentSet.hasOwnProperty(prop)) {\n                    if (prop === 'subComponentStyles' && currentSet.subComponentStyles !== undefined) {\n                        // subcomponent styles - style functions or objects\n                        var currentComponentStyles = currentSet.subComponentStyles;\n                        for (var subCompProp in currentComponentStyles) {\n                            if (currentComponentStyles.hasOwnProperty(subCompProp)) {\n                                if (workingSubcomponentStyles.hasOwnProperty(subCompProp)) {\n                                    workingSubcomponentStyles[subCompProp].push(currentComponentStyles[subCompProp]);\n                                }\n                                else {\n                                    workingSubcomponentStyles[subCompProp] = [currentComponentStyles[subCompProp]];\n                                }\n                            }\n                        }\n                        continue;\n                    }\n                    // the as any casts below is a workaround for ts 2.8.\n                    // todo: remove cast to any in ts 2.9.\n                    var mergedValue = mergedSet[prop];\n                    var currentValue = currentSet[prop];\n                    if (mergedValue === undefined) {\n                        mergedSet[prop] = currentValue;\n                    }\n                    else {\n                        mergedSet[prop] = __spreadArray(__spreadArray([], (Array.isArray(mergedValue) ? mergedValue : [mergedValue]), true), (Array.isArray(currentValue) ? currentValue : [currentValue]), true);\n                    }\n                }\n            }\n        }\n    }\n    if (Object.keys(workingSubcomponentStyles).length > 0) {\n        mergedSet.subComponentStyles = {};\n        var mergedSubStyles = mergedSet.subComponentStyles;\n        var _loop_1 = function (subCompProp) {\n            if (workingSubcomponentStyles.hasOwnProperty(subCompProp)) {\n                var workingSet_1 = workingSubcomponentStyles[subCompProp];\n                mergedSubStyles[subCompProp] = function (styleProps) {\n                    return concatStyleSets.apply(void 0, workingSet_1.map(function (styleFunctionOrObject) {\n                        return typeof styleFunctionOrObject === 'function' ? styleFunctionOrObject(styleProps) : styleFunctionOrObject;\n                    }));\n                };\n            }\n        };\n        // now we process the subcomponent styles if there are any\n        for (var subCompProp in workingSubcomponentStyles) {\n            _loop_1(subCompProp);\n        }\n    }\n    return mergedSet;\n}\n//# sourceMappingURL=concatStyleSets.js.map","import { __assign } from \"tslib\";\nimport { concatStyleSets } from './concatStyleSets';\nimport { extractStyleParts } from './extractStyleParts';\nimport { getStyleOptions } from './StyleOptionsState';\nimport { applyRegistration, styleToRegistration } from './styleToClassName';\nimport { isShadowConfig } from './shadowConfig';\nimport { Stylesheet } from './Stylesheet';\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n */\nexport function mergeStyleSets() {\n    var styleSets = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        styleSets[_i] = arguments[_i];\n    }\n    return mergeCssSets(styleSets, getStyleOptions());\n}\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets(styleSets, options) {\n    var classNameSet = { subComponentStyles: {} };\n    var shadowConfig = undefined;\n    var styleSet;\n    if (isShadowConfig(styleSets[0])) {\n        shadowConfig = styleSets[0];\n        styleSet = styleSets[1];\n    }\n    else {\n        styleSet = styleSets[0];\n    }\n    shadowConfig !== null && shadowConfig !== void 0 ? shadowConfig : (shadowConfig = options === null || options === void 0 ? void 0 : options.shadowConfig);\n    var opts = __assign(__assign({}, options), { shadowConfig: shadowConfig });\n    if (!styleSet && styleSets.length <= 1) {\n        return { subComponentStyles: {} };\n    }\n    var sheet = Stylesheet.getInstance(shadowConfig);\n    opts.stylesheet = sheet;\n    var concatenatedStyleSet = concatStyleSets.apply(void 0, styleSets);\n    var registrations = [];\n    for (var styleSetArea in concatenatedStyleSet) {\n        if (concatenatedStyleSet.hasOwnProperty(styleSetArea)) {\n            if (styleSetArea === 'subComponentStyles') {\n                classNameSet.subComponentStyles = concatenatedStyleSet.subComponentStyles || {};\n                continue;\n            }\n            else if (styleSetArea === '__shadowConfig__') {\n                continue;\n            }\n            var styles = concatenatedStyleSet[styleSetArea];\n            var _a = extractStyleParts(sheet, styles), classes = _a.classes, objects = _a.objects;\n            if (objects === null || objects === void 0 ? void 0 : objects.length) {\n                var registration = styleToRegistration(opts || {}, { displayName: styleSetArea }, objects);\n                if (registration) {\n                    registrations.push(registration);\n                    classNameSet[styleSetArea] = classes.concat([registration.className]).join(' ');\n                }\n            }\n            else {\n                classNameSet[styleSetArea] = classes.join(' ');\n            }\n        }\n    }\n    for (var _i = 0, registrations_1 = registrations; _i < registrations_1.length; _i++) {\n        var registration = registrations_1[_i];\n        if (registration) {\n            applyRegistration(registration, options === null || options === void 0 ? void 0 : options.specificityMultiplier, shadowConfig);\n        }\n    }\n    return classNameSet;\n}\n//# sourceMappingURL=mergeStyleSets.js.map","import * as React from 'react';\nimport { useConst } from './useConst';\n/**\n * Hook to store a value and generate callbacks for setting the value to true or false.\n * The identity of the callbacks will always stay the same.\n *\n * @param initialState - Initial value\n * @returns Array with the current value and an object containing the updater callbacks.\n */\nexport function useBoolean(initialState) {\n    var _a = React.useState(initialState), value = _a[0], setValue = _a[1];\n    var setTrue = useConst(function () { return function () {\n        setValue(true);\n    }; });\n    var setFalse = useConst(function () { return function () {\n        setValue(false);\n    }; });\n    var toggle = useConst(function () { return function () {\n        setValue(function (currentValue) { return !currentValue; });\n    }; });\n    return [value, { setTrue: setTrue, setFalse: setFalse, toggle: toggle }];\n}\n//# sourceMappingURL=useBoolean.js.map","import { __assign, __extends } from \"tslib\";\nimport * as React from 'react';\nimport { FocusZoneDirection, FocusZoneTabbableElements } from './FocusZone.types';\nimport { KeyCodes, css, elementContains, getDocument, getElementIndexPath, getFocusableByIndexPath, getId, getNativeProps, getNextElement, getParent, getPreviousElement, getRTL, htmlElementProperties, initializeComponentRef, isElementFocusSubZone, isElementFocusZone, isElementTabbable, shouldWrapFocus, warnDeprecations, portalContainsElement, findScrollableParent, createMergedRef, isElementVisibleAndNotHidden, MergeStylesShadowRootContext, } from '@fluentui/utilities';\nimport { mergeStyles } from '@fluentui/merge-styles';\nimport { getTheme } from '@fluentui/style-utilities';\nvar IS_FOCUSABLE_ATTRIBUTE = 'data-is-focusable';\nvar IS_ENTER_DISABLED_ATTRIBUTE = 'data-disable-click-on-enter';\nvar FOCUSZONE_ID_ATTRIBUTE = 'data-focuszone-id';\nvar TABINDEX = 'tabindex';\nvar NO_VERTICAL_WRAP = 'data-no-vertical-wrap';\nvar NO_HORIZONTAL_WRAP = 'data-no-horizontal-wrap';\nvar LARGE_DISTANCE_FROM_CENTER = 999999999;\nvar LARGE_NEGATIVE_DISTANCE_FROM_CENTER = -999999999;\nvar focusZoneStyles;\nvar focusZoneClass = 'ms-FocusZone';\n/**\n * Raises a click on a target element based on a keyboard event.\n */\nfunction raiseClickFromKeyboardEvent(target, ev) {\n    var event;\n    if (typeof MouseEvent === 'function') {\n        event = new MouseEvent('click', {\n            ctrlKey: ev === null || ev === void 0 ? void 0 : ev.ctrlKey,\n            metaKey: ev === null || ev === void 0 ? void 0 : ev.metaKey,\n            shiftKey: ev === null || ev === void 0 ? void 0 : ev.shiftKey,\n            altKey: ev === null || ev === void 0 ? void 0 : ev.altKey,\n            bubbles: ev === null || ev === void 0 ? void 0 : ev.bubbles,\n            cancelable: ev === null || ev === void 0 ? void 0 : ev.cancelable,\n        });\n    }\n    else {\n        // eslint-disable-next-line no-restricted-globals\n        event = document.createEvent('MouseEvents');\n        // eslint-disable-next-line deprecation/deprecation\n        event.initMouseEvent('click', ev ? ev.bubbles : false, ev ? ev.cancelable : false, \n        // eslint-disable-next-line no-restricted-globals\n        window, // not using getWindow() since this can only be run client side\n        0, // detail\n        0, // screen x\n        0, // screen y\n        0, // client x\n        0, // client y\n        ev ? ev.ctrlKey : false, ev ? ev.altKey : false, ev ? ev.shiftKey : false, ev ? ev.metaKey : false, 0, // button\n        null);\n    }\n    target.dispatchEvent(event);\n}\n// Helper function that will return a class for when the root is focused\nfunction getRootClass() {\n    if (!focusZoneStyles) {\n        focusZoneStyles = mergeStyles({\n            selectors: {\n                ':focus': {\n                    outline: 'none',\n                },\n            },\n        }, focusZoneClass);\n    }\n    return focusZoneStyles;\n}\nvar _allInstances = {};\nvar _outerZones = new Set();\nvar ALLOWED_INPUT_TYPES = ['text', 'number', 'password', 'email', 'tel', 'url', 'search', 'textarea'];\nvar ALLOW_VIRTUAL_ELEMENTS = false;\nvar FocusZone = /** @class */ (function (_super) {\n    __extends(FocusZone, _super);\n    function FocusZone(props) {\n        var _this = this;\n        var _a, _b, _c, _d;\n        _this = _super.call(this, props) || this;\n        _this._root = React.createRef();\n        _this._mergedRef = createMergedRef();\n        _this._onFocus = function (ev) {\n            if (_this._portalContainsElement(ev.target)) {\n                // If the event target is inside a portal do not process the event.\n                return;\n            }\n            var _a = _this.props, onActiveElementChanged = _a.onActiveElementChanged, \n            // eslint-disable-next-line deprecation/deprecation\n            doNotAllowFocusEventToPropagate = _a.doNotAllowFocusEventToPropagate, stopFocusPropagation = _a.stopFocusPropagation, \n            // eslint-disable-next-line deprecation/deprecation\n            onFocusNotification = _a.onFocusNotification, onFocus = _a.onFocus, shouldFocusInnerElementWhenReceivedFocus = _a.shouldFocusInnerElementWhenReceivedFocus, defaultTabbableElement = _a.defaultTabbableElement;\n            var isImmediateDescendant = _this._isImmediateDescendantOfZone(ev.target);\n            var newActiveElement;\n            if (isImmediateDescendant) {\n                newActiveElement = ev.target;\n            }\n            else {\n                var parentElement = ev.target;\n                while (parentElement && parentElement !== _this._root.current) {\n                    if (isElementTabbable(parentElement, undefined, _this._inShadowRoot) &&\n                        _this._isImmediateDescendantOfZone(parentElement)) {\n                        newActiveElement = parentElement;\n                        break;\n                    }\n                    parentElement = getParent(parentElement, ALLOW_VIRTUAL_ELEMENTS);\n                }\n            }\n            // If an inner focusable element should be focused when FocusZone container receives focus\n            if (shouldFocusInnerElementWhenReceivedFocus && ev.target === _this._root.current) {\n                var maybeElementToFocus = defaultTabbableElement &&\n                    typeof defaultTabbableElement === 'function' &&\n                    _this._root.current &&\n                    defaultTabbableElement(_this._root.current);\n                // try to focus defaultTabbable element\n                if (maybeElementToFocus && isElementTabbable(maybeElementToFocus, undefined, _this._inShadowRoot)) {\n                    newActiveElement = maybeElementToFocus;\n                    maybeElementToFocus.focus();\n                }\n                else {\n                    // force focus on first focusable element\n                    _this.focus(true);\n                    if (_this._activeElement) {\n                        // set to null as new active element was handled in method above\n                        newActiveElement = null;\n                    }\n                }\n            }\n            var initialElementFocused = !_this._activeElement;\n            // If the new active element is a child of this zone and received focus,\n            // update alignment an immediate descendant\n            if (newActiveElement && newActiveElement !== _this._activeElement) {\n                if (isImmediateDescendant || initialElementFocused) {\n                    _this._setFocusAlignment(newActiveElement, true, true);\n                }\n                _this._activeElement = newActiveElement;\n                if (initialElementFocused) {\n                    _this._updateTabIndexes();\n                }\n            }\n            if (onActiveElementChanged) {\n                onActiveElementChanged(_this._activeElement, ev);\n            }\n            if (stopFocusPropagation || doNotAllowFocusEventToPropagate) {\n                ev.stopPropagation();\n            }\n            if (onFocus) {\n                onFocus(ev);\n            }\n            else if (onFocusNotification) {\n                onFocusNotification();\n            }\n        };\n        _this._onBlur = function () {\n            _this._setParkedFocus(false);\n        };\n        _this._onMouseDown = function (ev) {\n            if (_this._portalContainsElement(ev.target)) {\n                // If the event target is inside a portal do not process the event.\n                return;\n            }\n            var disabled = _this.props.disabled;\n            if (disabled) {\n                return;\n            }\n            var target = ev.target;\n            var path = [];\n            while (target && target !== _this._root.current) {\n                path.push(target);\n                target = getParent(target, ALLOW_VIRTUAL_ELEMENTS);\n            }\n            while (path.length) {\n                target = path.pop();\n                if (target && isElementTabbable(target, undefined, _this._inShadowRoot)) {\n                    _this._setActiveElement(target, true);\n                }\n                if (isElementFocusZone(target)) {\n                    // Stop here since the focus zone will take care of its own children.\n                    break;\n                }\n            }\n        };\n        /**\n         * Handle the keystrokes.\n         */\n        _this._onKeyDown = function (ev, theme) {\n            if (_this._portalContainsElement(ev.target)) {\n                // If the event target is inside a portal do not process the event.\n                return;\n            }\n            // eslint-disable-next-line deprecation/deprecation\n            var _a = _this.props, direction = _a.direction, disabled = _a.disabled, isInnerZoneKeystroke = _a.isInnerZoneKeystroke, pagingSupportDisabled = _a.pagingSupportDisabled, shouldEnterInnerZone = _a.shouldEnterInnerZone;\n            if (disabled) {\n                return;\n            }\n            if (_this.props.onKeyDown) {\n                _this.props.onKeyDown(ev);\n            }\n            // If the default has been prevented, do not process keyboard events.\n            if (ev.isDefaultPrevented()) {\n                return;\n            }\n            if (_this._getDocument().activeElement === _this._root.current && _this._isInnerZone) {\n                // If this element has focus, it is being controlled by a parent.\n                // Ignore the keystroke.\n                return;\n            }\n            if (((shouldEnterInnerZone && shouldEnterInnerZone(ev)) || (isInnerZoneKeystroke && isInnerZoneKeystroke(ev))) &&\n                _this._isImmediateDescendantOfZone(ev.target)) {\n                // Try to focus\n                var innerZone = _this._getFirstInnerZone();\n                if (innerZone) {\n                    if (!innerZone.focus(true)) {\n                        return;\n                    }\n                }\n                else if (isElementFocusSubZone(ev.target)) {\n                    if (!_this.focusElement(getNextElement(ev.target, ev.target.firstChild, true))) {\n                        return;\n                    }\n                }\n                else {\n                    return;\n                }\n            }\n            else if (ev.altKey) {\n                return;\n            }\n            else {\n                // eslint-disable-next-line @fluentui/deprecated-keyboard-event-props, deprecation/deprecation\n                switch (ev.which) {\n                    case KeyCodes.space:\n                        if (_this._shouldRaiseClicksOnSpace && _this._tryInvokeClickForFocusable(ev.target, ev)) {\n                            break;\n                        }\n                        return;\n                    case KeyCodes.left:\n                        if (direction !== FocusZoneDirection.vertical) {\n                            _this._preventDefaultWhenHandled(ev);\n                            if (_this._moveFocusLeft(theme)) {\n                                break;\n                            }\n                        }\n                        return;\n                    case KeyCodes.right:\n                        if (direction !== FocusZoneDirection.vertical) {\n                            _this._preventDefaultWhenHandled(ev);\n                            if (_this._moveFocusRight(theme)) {\n                                break;\n                            }\n                        }\n                        return;\n                    case KeyCodes.up:\n                        if (direction !== FocusZoneDirection.horizontal) {\n                            _this._preventDefaultWhenHandled(ev);\n                            if (_this._moveFocusUp()) {\n                                break;\n                            }\n                        }\n                        return;\n                    case KeyCodes.down:\n                        if (direction !== FocusZoneDirection.horizontal) {\n                            _this._preventDefaultWhenHandled(ev);\n                            if (_this._moveFocusDown()) {\n                                break;\n                            }\n                        }\n                        return;\n                    case KeyCodes.pageDown:\n                        if (!pagingSupportDisabled && _this._moveFocusPaging(true)) {\n                            break;\n                        }\n                        return;\n                    case KeyCodes.pageUp:\n                        if (!pagingSupportDisabled && _this._moveFocusPaging(false)) {\n                            break;\n                        }\n                        return;\n                    case KeyCodes.tab:\n                        if (\n                        // eslint-disable-next-line deprecation/deprecation\n                        _this.props.allowTabKey ||\n                            _this.props.handleTabKey === FocusZoneTabbableElements.all ||\n                            (_this.props.handleTabKey === FocusZoneTabbableElements.inputOnly &&\n                                _this._isElementInput(ev.target))) {\n                            var focusChanged = false;\n                            _this._processingTabKey = true;\n                            if (direction === FocusZoneDirection.vertical ||\n                                !_this._shouldWrapFocus(_this._activeElement, NO_HORIZONTAL_WRAP)) {\n                                focusChanged = ev.shiftKey ? _this._moveFocusUp() : _this._moveFocusDown();\n                            }\n                            else {\n                                var tabWithDirection = getRTL(theme) ? !ev.shiftKey : ev.shiftKey;\n                                focusChanged = tabWithDirection ? _this._moveFocusLeft(theme) : _this._moveFocusRight(theme);\n                            }\n                            _this._processingTabKey = false;\n                            if (focusChanged) {\n                                break;\n                            }\n                            else if (_this.props.shouldResetActiveElementWhenTabFromZone) {\n                                _this._activeElement = null;\n                            }\n                        }\n                        return;\n                    case KeyCodes.home:\n                        if (_this._isContentEditableElement(ev.target) ||\n                            (_this._isElementInput(ev.target) &&\n                                !_this._shouldInputLoseFocus(ev.target, false))) {\n                            return false;\n                        }\n                        var firstChild = _this._root.current && _this._root.current.firstChild;\n                        if (_this._root.current &&\n                            firstChild &&\n                            _this.focusElement(getNextElement(_this._root.current, firstChild, true))) {\n                            break;\n                        }\n                        return;\n                    case KeyCodes.end:\n                        if (_this._isContentEditableElement(ev.target) ||\n                            (_this._isElementInput(ev.target) &&\n                                !_this._shouldInputLoseFocus(ev.target, true))) {\n                            return false;\n                        }\n                        var lastChild = _this._root.current && _this._root.current.lastChild;\n                        if (_this._root.current &&\n                            _this.focusElement(getPreviousElement(_this._root.current, lastChild, true, true, true))) {\n                            break;\n                        }\n                        return;\n                    case KeyCodes.enter:\n                        if (_this._shouldRaiseClicksOnEnter && _this._tryInvokeClickForFocusable(ev.target, ev)) {\n                            break;\n                        }\n                        return;\n                    default:\n                        return;\n                }\n            }\n            ev.preventDefault();\n            ev.stopPropagation();\n        };\n        _this._getHorizontalDistanceFromCenter = function (isForward, \n        // eslint-disable-next-line deprecation/deprecation\n        activeRect, \n        // eslint-disable-next-line deprecation/deprecation\n        targetRect) {\n            // eslint-disable-next-line deprecation/deprecation\n            var leftAlignment = _this._focusAlignment.left || _this._focusAlignment.x || 0;\n            // ClientRect values can be floats that differ by very small fractions of a decimal.\n            // If the difference between top and bottom are within a pixel then we should treat\n            // them as equivalent by using Math.floor. For instance 5.2222 and 5.222221 should be equivalent,\n            // but without Math.Floor they will be handled incorrectly.\n            var targetRectTop = Math.floor(targetRect.top);\n            var activeRectBottom = Math.floor(activeRect.bottom);\n            var targetRectBottom = Math.floor(targetRect.bottom);\n            var activeRectTop = Math.floor(activeRect.top);\n            var isValidCandidateOnpagingDown = isForward && targetRectTop > activeRectBottom;\n            var isValidCandidateOnpagingUp = !isForward && targetRectBottom < activeRectTop;\n            if (isValidCandidateOnpagingDown || isValidCandidateOnpagingUp) {\n                if (leftAlignment >= targetRect.left && leftAlignment <= targetRect.left + targetRect.width) {\n                    return 0;\n                }\n                return Math.abs(targetRect.left + targetRect.width / 2 - leftAlignment);\n            }\n            if (!_this._shouldWrapFocus(_this._activeElement, NO_VERTICAL_WRAP)) {\n                return LARGE_NEGATIVE_DISTANCE_FROM_CENTER;\n            }\n            return LARGE_DISTANCE_FROM_CENTER;\n        };\n        // Manage componentRef resolution.\n        initializeComponentRef(_this);\n        if (process.env.NODE_ENV !== 'production') {\n            warnDeprecations('FocusZone', props, {\n                rootProps: undefined,\n                allowTabKey: 'handleTabKey',\n                elementType: 'as',\n                ariaDescribedBy: 'aria-describedby',\n                ariaLabelledBy: 'aria-labelledby',\n            });\n        }\n        _this._id = getId('FocusZone');\n        _this._focusAlignment = {\n            left: 0,\n            top: 0,\n        };\n        _this._processingTabKey = false;\n        var shouldRaiseClicksFallback = (_b = (_a = props.shouldRaiseClicks) !== null && _a !== void 0 ? _a : FocusZone.defaultProps.shouldRaiseClicks) !== null && _b !== void 0 ? _b : true;\n        _this._shouldRaiseClicksOnEnter = (_c = props.shouldRaiseClicksOnEnter) !== null && _c !== void 0 ? _c : shouldRaiseClicksFallback;\n        _this._shouldRaiseClicksOnSpace = (_d = props.shouldRaiseClicksOnSpace) !== null && _d !== void 0 ? _d : shouldRaiseClicksFallback;\n        return _this;\n    }\n    /** Used for testing purposes only. */\n    FocusZone.getOuterZones = function () {\n        return _outerZones.size;\n    };\n    /**\n     * Handle global tab presses so that we can patch tabindexes on the fly.\n     * HEADS UP: This must not be an arrow function in order to be referentially equal among instances\n     * for ref counting to work correctly!\n     */\n    FocusZone._onKeyDownCapture = function (ev) {\n        // eslint-disable-next-line deprecation/deprecation, @fluentui/deprecated-keyboard-event-props\n        if (ev.which === KeyCodes.tab) {\n            _outerZones.forEach(function (zone) { return zone._updateTabIndexes(); });\n        }\n    };\n    FocusZone.prototype.componentDidMount = function () {\n        var _a;\n        var root = this._root.current;\n        this._inShadowRoot = !!((_a = this.context) === null || _a === void 0 ? void 0 : _a.shadowRoot);\n        _allInstances[this._id] = this;\n        if (root) {\n            var parentElement = getParent(root, ALLOW_VIRTUAL_ELEMENTS);\n            while (parentElement && parentElement !== this._getDocument().body && parentElement.nodeType === 1) {\n                if (isElementFocusZone(parentElement)) {\n                    this._isInnerZone = true;\n                    break;\n                }\n                parentElement = getParent(parentElement, ALLOW_VIRTUAL_ELEMENTS);\n            }\n            if (!this._isInnerZone) {\n                _outerZones.add(this);\n                this._root.current && this._root.current.addEventListener('keydown', FocusZone._onKeyDownCapture, true);\n            }\n            this._root.current && this._root.current.addEventListener('blur', this._onBlur, true);\n            // Assign initial tab indexes so that we can set initial focus as appropriate.\n            this._updateTabIndexes();\n            if (this.props.defaultTabbableElement && typeof this.props.defaultTabbableElement === 'string') {\n                this._activeElement = this._getDocument().querySelector(this.props.defaultTabbableElement);\n                // eslint-disable-next-line deprecation/deprecation\n            }\n            else if (this.props.defaultActiveElement) {\n                // eslint-disable-next-line deprecation/deprecation\n                this._activeElement = this._getDocument().querySelector(this.props.defaultActiveElement);\n            }\n            if (this.props.shouldFocusOnMount) {\n                this.focus();\n            }\n        }\n    };\n    FocusZone.prototype.componentDidUpdate = function () {\n        var _a;\n        var root = this._root.current;\n        var doc = this._getDocument();\n        this._inShadowRoot = !!((_a = this.context) === null || _a === void 0 ? void 0 : _a.shadowRoot);\n        // If either _activeElement or _defaultFocusElement are no longer contained by _root,\n        // reset those variables (and update tab indexes) to avoid memory leaks\n        if ((this._activeElement && !elementContains(this._root.current, this._activeElement, ALLOW_VIRTUAL_ELEMENTS)) ||\n            (this._defaultFocusElement &&\n                !elementContains(this._root.current, this._defaultFocusElement, ALLOW_VIRTUAL_ELEMENTS))) {\n            this._activeElement = null;\n            this._defaultFocusElement = null;\n            this._updateTabIndexes();\n        }\n        if (!this.props.preventFocusRestoration &&\n            doc &&\n            this._lastIndexPath &&\n            (doc.activeElement === doc.body || doc.activeElement === null || doc.activeElement === root)) {\n            // The element has been removed after the render, attempt to restore focus.\n            var elementToFocus = getFocusableByIndexPath(root, this._lastIndexPath);\n            if (elementToFocus) {\n                this._setActiveElement(elementToFocus, true);\n                elementToFocus.focus();\n                this._setParkedFocus(false);\n            }\n            else {\n                // We had a focus path to restore, but now that path is unresolvable. Park focus\n                // on the container until we can try again.\n                this._setParkedFocus(true);\n            }\n        }\n    };\n    FocusZone.prototype.componentWillUnmount = function () {\n        delete _allInstances[this._id];\n        if (!this._isInnerZone) {\n            _outerZones.delete(this);\n            this._root.current && this._root.current.removeEventListener('keydown', FocusZone._onKeyDownCapture, true);\n        }\n        if (this._root.current) {\n            this._root.current.removeEventListener('blur', this._onBlur, true);\n        }\n        this._activeElement = null;\n        this._defaultFocusElement = null;\n    };\n    FocusZone.prototype.render = function () {\n        var _this = this;\n        // eslint-disable-next-line deprecation/deprecation\n        var _a = this.props, tag = _a.as, elementType = _a.elementType, rootProps = _a.rootProps, ariaDescribedBy = _a.ariaDescribedBy, ariaLabelledBy = _a.ariaLabelledBy, className = _a.className;\n        var divProps = getNativeProps(this.props, htmlElementProperties);\n        var Tag = tag || elementType || 'div';\n        // Note, right before rendering/reconciling proceeds, we need to record if focus\n        // was in the zone before the update. This helper will track this and, if focus\n        // was actually in the zone, what the index path to the element is at this time.\n        // Then, later in componentDidUpdate, we can evaluate if we need to restore it in\n        // the case the element was removed.\n        this._evaluateFocusBeforeRender();\n        // Only support RTL defined in global theme, not contextual theme/RTL.\n        var theme = getTheme();\n        return (React.createElement(Tag, __assign({ \"aria-labelledby\": ariaLabelledBy, \"aria-describedby\": ariaDescribedBy }, divProps, rootProps, { \n            // Once the getClassName correctly memoizes inputs this should\n            // be replaced so that className is passed to getRootClass and is included there so\n            // the class names will always be in the same order.\n            className: css(getRootClass(), className), \n            // eslint-disable-next-line deprecation/deprecation\n            ref: this._mergedRef(this.props.elementRef, this._root), \"data-focuszone-id\": this._id, \n            // eslint-disable-next-line react/jsx-no-bind\n            onKeyDown: function (ev) { return _this._onKeyDown(ev, theme); }, onFocus: this._onFocus, onMouseDownCapture: this._onMouseDown }), this.props.children));\n    };\n    /**\n     * Sets focus to the first tabbable item in the zone.\n     * @param forceIntoFirstElement - If true, focus will be forced into the first element, even\n     * if focus is already in the focus zone.\n     * @param bypassHiddenElements - If true, focus will be not be set on hidden elements.\n     * @returns True if focus could be set to an active element, false if no operation was taken.\n     */\n    FocusZone.prototype.focus = function (forceIntoFirstElement, bypassHiddenElements) {\n        if (forceIntoFirstElement === void 0) { forceIntoFirstElement = false; }\n        if (bypassHiddenElements === void 0) { bypassHiddenElements = false; }\n        if (this._root.current) {\n            if (!forceIntoFirstElement &&\n                this._root.current.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'true' &&\n                this._isInnerZone) {\n                var ownerZoneElement = this._getOwnerZone(this._root.current);\n                if (ownerZoneElement !== this._root.current) {\n                    var ownerZone = _allInstances[ownerZoneElement.getAttribute(FOCUSZONE_ID_ATTRIBUTE)];\n                    return !!ownerZone && ownerZone.focusElement(this._root.current);\n                }\n                return false;\n            }\n            else if (!forceIntoFirstElement &&\n                this._activeElement &&\n                elementContains(this._root.current, this._activeElement) &&\n                isElementTabbable(this._activeElement, undefined, this._inShadowRoot) &&\n                (!bypassHiddenElements || isElementVisibleAndNotHidden(this._activeElement))) {\n                this._activeElement.focus();\n                return true;\n            }\n            else {\n                var firstChild = this._root.current.firstChild;\n                return this.focusElement(getNextElement(this._root.current, firstChild, true, undefined, undefined, undefined, undefined, undefined, bypassHiddenElements));\n            }\n        }\n        return false;\n    };\n    /**\n     * Sets focus to the last tabbable item in the zone.\n     * @returns True if focus could be set to an active element, false if no operation was taken.\n     */\n    FocusZone.prototype.focusLast = function () {\n        if (this._root.current) {\n            var lastChild = this._root.current && this._root.current.lastChild;\n            return this.focusElement(getPreviousElement(this._root.current, lastChild, true, true, true));\n        }\n        return false;\n    };\n    /**\n     * Sets focus to a specific child element within the zone. This can be used in conjunction with\n     * shouldReceiveFocus to create delayed focus scenarios (like animate the scroll position to the correct\n     * location and then focus.)\n     * @param element - The child element within the zone to focus.\n     * @param forceAlignment - If true, focus alignment will be set according to the element provided.\n     * @returns True if focus could be set to an active element, false if no operation was taken.\n     */\n    FocusZone.prototype.focusElement = function (element, forceAlignment) {\n        // eslint-disable-next-line deprecation/deprecation\n        var _a = this.props, onBeforeFocus = _a.onBeforeFocus, shouldReceiveFocus = _a.shouldReceiveFocus;\n        if ((shouldReceiveFocus && !shouldReceiveFocus(element)) || (onBeforeFocus && !onBeforeFocus(element))) {\n            return false;\n        }\n        if (element) {\n            // when we set focus to a specific child, we should recalculate the alignment depending on its position.\n            this._setActiveElement(element, forceAlignment);\n            if (this._activeElement) {\n                this._activeElement.focus();\n            }\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Forces horizontal alignment in the context of vertical arrowing to use specific point as the reference,\n     * rather than a center based on the last horizontal motion.\n     * @param point - the new reference point.\n     */\n    FocusZone.prototype.setFocusAlignment = function (point) {\n        this._focusAlignment = point;\n    };\n    Object.defineProperty(FocusZone.prototype, \"defaultFocusElement\", {\n        get: function () {\n            return this._defaultFocusElement;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(FocusZone.prototype, \"activeElement\", {\n        get: function () {\n            return this._activeElement;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    FocusZone.prototype._evaluateFocusBeforeRender = function () {\n        var root = this._root.current;\n        var doc = this._getDocument();\n        if (doc) {\n            var focusedElement = doc.activeElement;\n            // Only update the index path if we are not parked on the root.\n            if (focusedElement !== root) {\n                var shouldRestoreFocus = elementContains(root, focusedElement, false);\n                this._lastIndexPath = shouldRestoreFocus ? getElementIndexPath(root, focusedElement) : undefined;\n            }\n        }\n    };\n    /**\n     * When focus is in the zone at render time but then all focusable elements are removed,\n     * we \"park\" focus temporarily on the root. Once we update with focusable children, we restore\n     * focus to the closest path from previous. If the user tabs away from the parked container,\n     * we restore focusability to the pre-parked state.\n     */\n    FocusZone.prototype._setParkedFocus = function (isParked) {\n        var root = this._root.current;\n        if (root && this._isParked !== isParked) {\n            this._isParked = isParked;\n            if (isParked) {\n                if (!this.props.allowFocusRoot) {\n                    this._parkedTabIndex = root.getAttribute('tabindex');\n                    root.setAttribute('tabindex', '-1');\n                }\n                root.focus();\n            }\n            else if (!this.props.allowFocusRoot) {\n                if (this._parkedTabIndex) {\n                    root.setAttribute('tabindex', this._parkedTabIndex);\n                    this._parkedTabIndex = undefined;\n                }\n                else {\n                    root.removeAttribute('tabindex');\n                }\n            }\n        }\n    };\n    FocusZone.prototype._setActiveElement = function (element, forceAlignment) {\n        var previousActiveElement = this._activeElement;\n        this._activeElement = element;\n        if (previousActiveElement) {\n            if (isElementFocusZone(previousActiveElement)) {\n                this._updateTabIndexes(previousActiveElement);\n            }\n            previousActiveElement.tabIndex = -1;\n        }\n        if (this._activeElement) {\n            if (!this._focusAlignment || forceAlignment) {\n                this._setFocusAlignment(element, true, true);\n            }\n            this._activeElement.tabIndex = 0;\n        }\n    };\n    FocusZone.prototype._preventDefaultWhenHandled = function (ev) {\n        this.props.preventDefaultWhenHandled && ev.preventDefault();\n    };\n    /**\n     * Walk up the dom try to find a focusable element.\n     */\n    FocusZone.prototype._tryInvokeClickForFocusable = function (targetElement, ev) {\n        var target = targetElement;\n        if (target === this._root.current) {\n            return false;\n        }\n        do {\n            if (target.tagName === 'BUTTON' ||\n                target.tagName === 'A' ||\n                target.tagName === 'INPUT' ||\n                target.tagName === 'TEXTAREA' ||\n                target.tagName === 'SUMMARY') {\n                return false;\n            }\n            if (this._isImmediateDescendantOfZone(target) &&\n                target.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'true' &&\n                target.getAttribute(IS_ENTER_DISABLED_ATTRIBUTE) !== 'true') {\n                raiseClickFromKeyboardEvent(target, ev);\n                return true;\n            }\n            target = getParent(target, ALLOW_VIRTUAL_ELEMENTS);\n        } while (target !== this._root.current);\n        return false;\n    };\n    /**\n     * Traverse to find first child zone.\n     */\n    FocusZone.prototype._getFirstInnerZone = function (rootElement) {\n        rootElement = rootElement || this._activeElement || this._root.current;\n        if (!rootElement) {\n            return null;\n        }\n        if (isElementFocusZone(rootElement)) {\n            return _allInstances[rootElement.getAttribute(FOCUSZONE_ID_ATTRIBUTE)];\n        }\n        var child = rootElement.firstElementChild;\n        while (child) {\n            if (isElementFocusZone(child)) {\n                return _allInstances[child.getAttribute(FOCUSZONE_ID_ATTRIBUTE)];\n            }\n            var match = this._getFirstInnerZone(child);\n            if (match) {\n                return match;\n            }\n            child = child.nextElementSibling;\n        }\n        return null;\n    };\n    FocusZone.prototype._moveFocus = function (isForward, \n    // eslint-disable-next-line deprecation/deprecation\n    getDistanceFromCenter, ev, useDefaultWrap) {\n        if (useDefaultWrap === void 0) { useDefaultWrap = true; }\n        var element = this._activeElement;\n        var candidateDistance = -1;\n        var candidateElement = undefined;\n        var changedFocus = false;\n        var isBidirectional = this.props.direction === FocusZoneDirection.bidirectional;\n        if (!element || !this._root.current) {\n            return false;\n        }\n        if (this._isElementInput(element)) {\n            if (!this._shouldInputLoseFocus(element, isForward)) {\n                return false;\n            }\n        }\n        var activeRect = isBidirectional ? element.getBoundingClientRect() : null;\n        do {\n            element = (isForward ? getNextElement(this._root.current, element) : getPreviousElement(this._root.current, element));\n            if (isBidirectional) {\n                if (element) {\n                    var targetRect = element.getBoundingClientRect();\n                    // eslint-disable-next-line deprecation/deprecation\n                    var elementDistance = getDistanceFromCenter(activeRect, targetRect);\n                    if (elementDistance === -1 && candidateDistance === -1) {\n                        candidateElement = element;\n                        break;\n                    }\n                    if (elementDistance > -1 && (candidateDistance === -1 || elementDistance < candidateDistance)) {\n                        candidateDistance = elementDistance;\n                        candidateElement = element;\n                    }\n                    if (candidateDistance >= 0 && elementDistance < 0) {\n                        break;\n                    }\n                }\n            }\n            else {\n                candidateElement = element;\n                break;\n            }\n        } while (element);\n        // Focus the closest candidate\n        if (candidateElement && candidateElement !== this._activeElement) {\n            changedFocus = true;\n            this.focusElement(candidateElement);\n        }\n        else if (this.props.isCircularNavigation && useDefaultWrap) {\n            if (isForward) {\n                return this.focusElement(getNextElement(this._root.current, this._root.current.firstElementChild, true));\n            }\n            else {\n                return this.focusElement(getPreviousElement(this._root.current, this._root.current.lastElementChild, true, true, true));\n            }\n        }\n        return changedFocus;\n    };\n    FocusZone.prototype._moveFocusDown = function () {\n        var _this = this;\n        var targetTop = -1;\n        // eslint-disable-next-line deprecation/deprecation\n        var leftAlignment = this._focusAlignment.left || this._focusAlignment.x || 0;\n        if (\n        // eslint-disable-next-line deprecation/deprecation\n        this._moveFocus(true, function (activeRect, targetRect) {\n            var distance = -1;\n            // ClientRect values can be floats that differ by very small fractions of a decimal.\n            // If the difference between top and bottom are within a pixel then we should treat\n            // them as equivalent by using Math.floor. For instance 5.2222 and 5.222221 should be equivalent,\n            // but without Math.Floor they will be handled incorrectly.\n            var targetRectTop = Math.floor(targetRect.top);\n            var activeRectBottom = Math.floor(activeRect.bottom);\n            if (targetRectTop < activeRectBottom) {\n                if (!_this._shouldWrapFocus(_this._activeElement, NO_VERTICAL_WRAP)) {\n                    return LARGE_NEGATIVE_DISTANCE_FROM_CENTER;\n                }\n                return LARGE_DISTANCE_FROM_CENTER;\n            }\n            if ((targetTop === -1 && targetRectTop >= activeRectBottom) || targetRectTop === targetTop) {\n                targetTop = targetRectTop;\n                if (leftAlignment >= targetRect.left && leftAlignment <= targetRect.left + targetRect.width) {\n                    distance = 0;\n                }\n                else {\n                    distance = Math.abs(targetRect.left + targetRect.width / 2 - leftAlignment);\n                }\n            }\n            return distance;\n        })) {\n            this._setFocusAlignment(this._activeElement, false, true);\n            return true;\n        }\n        return false;\n    };\n    FocusZone.prototype._moveFocusUp = function () {\n        var _this = this;\n        var targetTop = -1;\n        // eslint-disable-next-line deprecation/deprecation\n        var leftAlignment = this._focusAlignment.left || this._focusAlignment.x || 0;\n        if (\n        // eslint-disable-next-line deprecation/deprecation\n        this._moveFocus(false, function (activeRect, targetRect) {\n            var distance = -1;\n            // ClientRect values can be floats that differ by very small fractions of a decimal.\n            // If the difference between top and bottom are within a pixel then we should treat\n            // them as equivalent by using Math.floor. For instance 5.2222 and 5.222221 should be equivalent,\n            // but without Math.Floor they will be handled incorrectly.\n            var targetRectBottom = Math.floor(targetRect.bottom);\n            var targetRectTop = Math.floor(targetRect.top);\n            var activeRectTop = Math.floor(activeRect.top);\n            if (targetRectBottom > activeRectTop) {\n                if (!_this._shouldWrapFocus(_this._activeElement, NO_VERTICAL_WRAP)) {\n                    return LARGE_NEGATIVE_DISTANCE_FROM_CENTER;\n                }\n                return LARGE_DISTANCE_FROM_CENTER;\n            }\n            if ((targetTop === -1 && targetRectBottom <= activeRectTop) || targetRectTop === targetTop) {\n                targetTop = targetRectTop;\n                if (leftAlignment >= targetRect.left && leftAlignment <= targetRect.left + targetRect.width) {\n                    distance = 0;\n                }\n                else {\n                    distance = Math.abs(targetRect.left + targetRect.width / 2 - leftAlignment);\n                }\n            }\n            return distance;\n        })) {\n            this._setFocusAlignment(this._activeElement, false, true);\n            return true;\n        }\n        return false;\n    };\n    FocusZone.prototype._moveFocusLeft = function (theme) {\n        var _this = this;\n        var shouldWrap = this._shouldWrapFocus(this._activeElement, NO_HORIZONTAL_WRAP);\n        if (this._moveFocus(getRTL(theme), \n        // eslint-disable-next-line deprecation/deprecation\n        function (activeRect, targetRect) {\n            var distance = -1;\n            var topBottomComparison;\n            if (getRTL(theme)) {\n                // When in RTL, this comparison should be the same as the one in _moveFocusRight for LTR.\n                // Going left at a leftmost rectangle will go down a line instead of up a line like in LTR.\n                // This is important, because we want to be comparing the top of the target rect\n                // with the bottom of the active rect.\n                topBottomComparison = parseFloat(targetRect.top.toFixed(3)) < parseFloat(activeRect.bottom.toFixed(3));\n            }\n            else {\n                topBottomComparison = parseFloat(targetRect.bottom.toFixed(3)) > parseFloat(activeRect.top.toFixed(3));\n            }\n            if (topBottomComparison &&\n                targetRect.right <= activeRect.right &&\n                _this.props.direction !== FocusZoneDirection.vertical) {\n                distance = activeRect.right - targetRect.right;\n            }\n            else if (!shouldWrap) {\n                distance = LARGE_NEGATIVE_DISTANCE_FROM_CENTER;\n            }\n            return distance;\n        }, undefined /*ev*/, shouldWrap)) {\n            this._setFocusAlignment(this._activeElement, true, false);\n            return true;\n        }\n        return false;\n    };\n    FocusZone.prototype._moveFocusRight = function (theme) {\n        var _this = this;\n        var shouldWrap = this._shouldWrapFocus(this._activeElement, NO_HORIZONTAL_WRAP);\n        if (this._moveFocus(!getRTL(theme), \n        // eslint-disable-next-line deprecation/deprecation\n        function (activeRect, targetRect) {\n            var distance = -1;\n            var topBottomComparison;\n            if (getRTL(theme)) {\n                // When in RTL, this comparison should be the same as the one in _moveFocusLeft for LTR.\n                // Going right at a rightmost rectangle will go up a line instead of down a line like in LTR.\n                // This is important, because we want to be comparing the bottom of the target rect\n                // with the top of the active rect.\n                topBottomComparison = parseFloat(targetRect.bottom.toFixed(3)) > parseFloat(activeRect.top.toFixed(3));\n            }\n            else {\n                topBottomComparison = parseFloat(targetRect.top.toFixed(3)) < parseFloat(activeRect.bottom.toFixed(3));\n            }\n            if (topBottomComparison &&\n                targetRect.left >= activeRect.left &&\n                _this.props.direction !== FocusZoneDirection.vertical) {\n                distance = targetRect.left - activeRect.left;\n            }\n            else if (!shouldWrap) {\n                distance = LARGE_NEGATIVE_DISTANCE_FROM_CENTER;\n            }\n            return distance;\n        }, undefined /*ev*/, shouldWrap)) {\n            this._setFocusAlignment(this._activeElement, true, false);\n            return true;\n        }\n        return false;\n    };\n    FocusZone.prototype._moveFocusPaging = function (isForward, useDefaultWrap) {\n        if (useDefaultWrap === void 0) { useDefaultWrap = true; }\n        var element = this._activeElement;\n        if (!element || !this._root.current) {\n            return false;\n        }\n        if (this._isElementInput(element)) {\n            if (!this._shouldInputLoseFocus(element, isForward)) {\n                return false;\n            }\n        }\n        var scrollableParent = findScrollableParent(element);\n        if (!scrollableParent) {\n            return false;\n        }\n        var candidateDistance = -1;\n        var candidateElement = undefined;\n        var targetTop = -1;\n        var targetBottom = -1;\n        var pagesize = scrollableParent.clientHeight;\n        var activeRect = element.getBoundingClientRect();\n        do {\n            element = isForward\n                ? getNextElement(this._root.current, element)\n                : getPreviousElement(this._root.current, element);\n            if (element) {\n                var targetRect = element.getBoundingClientRect();\n                var targetRectTop = Math.floor(targetRect.top);\n                var activeRectBottom = Math.floor(activeRect.bottom);\n                var targetRectBottom = Math.floor(targetRect.bottom);\n                var activeRectTop = Math.floor(activeRect.top);\n                var elementDistance = this._getHorizontalDistanceFromCenter(isForward, activeRect, targetRect);\n                var isElementPassedPageSizeOnPagingDown = isForward && targetRectTop > activeRectBottom + pagesize;\n                var isElementPassedPageSizeOnPagingUp = !isForward && targetRectBottom < activeRectTop - pagesize;\n                if (isElementPassedPageSizeOnPagingDown || isElementPassedPageSizeOnPagingUp) {\n                    break;\n                }\n                if (elementDistance > -1) {\n                    // for paging down\n                    if (isForward && targetRectTop > targetTop) {\n                        targetTop = targetRectTop;\n                        candidateDistance = elementDistance;\n                        candidateElement = element;\n                    }\n                    else if (!isForward && targetRectBottom < targetBottom) {\n                        // for paging up\n                        targetBottom = targetRectBottom;\n                        candidateDistance = elementDistance;\n                        candidateElement = element;\n                    }\n                    else if (candidateDistance === -1 || elementDistance <= candidateDistance) {\n                        candidateDistance = elementDistance;\n                        candidateElement = element;\n                    }\n                }\n            }\n        } while (element);\n        var changedFocus = false;\n        // Focus the closest candidate\n        if (candidateElement && candidateElement !== this._activeElement) {\n            changedFocus = true;\n            this.focusElement(candidateElement);\n            this._setFocusAlignment(candidateElement, false, true);\n        }\n        else if (this.props.isCircularNavigation && useDefaultWrap) {\n            if (isForward) {\n                return this.focusElement(getNextElement(this._root.current, this._root.current.firstElementChild, true));\n            }\n            return this.focusElement(getPreviousElement(this._root.current, this._root.current.lastElementChild, true, true, true));\n        }\n        return changedFocus;\n    };\n    FocusZone.prototype._setFocusAlignment = function (element, isHorizontal, isVertical) {\n        if (this.props.direction === FocusZoneDirection.bidirectional &&\n            (!this._focusAlignment || isHorizontal || isVertical)) {\n            var rect = element.getBoundingClientRect();\n            var left = rect.left + rect.width / 2;\n            var top_1 = rect.top + rect.height / 2;\n            if (!this._focusAlignment) {\n                this._focusAlignment = { left: left, top: top_1 };\n            }\n            if (isHorizontal) {\n                this._focusAlignment.left = left;\n            }\n            if (isVertical) {\n                this._focusAlignment.top = top_1;\n            }\n        }\n    };\n    FocusZone.prototype._isImmediateDescendantOfZone = function (element) {\n        return this._getOwnerZone(element) === this._root.current;\n    };\n    FocusZone.prototype._getOwnerZone = function (element) {\n        var parentElement = getParent(element, ALLOW_VIRTUAL_ELEMENTS);\n        while (parentElement && parentElement !== this._root.current && parentElement !== this._getDocument().body) {\n            if (isElementFocusZone(parentElement)) {\n                return parentElement;\n            }\n            parentElement = getParent(parentElement, ALLOW_VIRTUAL_ELEMENTS);\n        }\n        return parentElement;\n    };\n    FocusZone.prototype._updateTabIndexes = function (element) {\n        if (!this._activeElement &&\n            this.props.defaultTabbableElement &&\n            typeof this.props.defaultTabbableElement === 'function') {\n            this._activeElement = this.props.defaultTabbableElement(this._root.current);\n        }\n        if (!element && this._root.current) {\n            this._defaultFocusElement = null;\n            element = this._root.current;\n            if (this._activeElement && !elementContains(element, this._activeElement)) {\n                this._activeElement = null;\n            }\n        }\n        // If active element changes state to disabled, set it to null.\n        // Otherwise, we lose keyboard accessibility to other elements in focus zone.\n        if (this._activeElement && !isElementTabbable(this._activeElement, undefined, this._inShadowRoot)) {\n            this._activeElement = null;\n        }\n        var childNodes = element && element.children;\n        for (var childIndex = 0; childNodes && childIndex < childNodes.length; childIndex++) {\n            var child = childNodes[childIndex];\n            if (!isElementFocusZone(child)) {\n                // If the item is explicitly set to not be focusable then TABINDEX needs to be set to -1.\n                if (child.getAttribute && child.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'false') {\n                    child.setAttribute(TABINDEX, '-1');\n                }\n                if (isElementTabbable(child, undefined, this._inShadowRoot)) {\n                    if (this.props.disabled) {\n                        child.setAttribute(TABINDEX, '-1');\n                    }\n                    else if (!this._isInnerZone &&\n                        ((!this._activeElement && !this._defaultFocusElement) || this._activeElement === child)) {\n                        this._defaultFocusElement = child;\n                        if (child.getAttribute(TABINDEX) !== '0') {\n                            child.setAttribute(TABINDEX, '0');\n                        }\n                    }\n                    else if (child.getAttribute(TABINDEX) !== '-1') {\n                        child.setAttribute(TABINDEX, '-1');\n                    }\n                }\n                else if (child.tagName === 'svg' && child.getAttribute('focusable') !== 'false') {\n                    // Disgusting IE hack. Sad face.\n                    child.setAttribute('focusable', 'false');\n                }\n            }\n            else if (child.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'true') {\n                if (!this._isInnerZone &&\n                    ((!this._activeElement && !this._defaultFocusElement) || this._activeElement === child)) {\n                    this._defaultFocusElement = child;\n                    if (child.getAttribute(TABINDEX) !== '0') {\n                        child.setAttribute(TABINDEX, '0');\n                    }\n                }\n                else if (child.getAttribute(TABINDEX) !== '-1') {\n                    child.setAttribute(TABINDEX, '-1');\n                }\n            }\n            this._updateTabIndexes(child);\n        }\n    };\n    FocusZone.prototype._isContentEditableElement = function (element) {\n        return element && element.getAttribute('contenteditable') === 'true';\n    };\n    FocusZone.prototype._isElementInput = function (element) {\n        if (element &&\n            element.tagName &&\n            (element.tagName.toLowerCase() === 'input' || element.tagName.toLowerCase() === 'textarea')) {\n            return true;\n        }\n        return false;\n    };\n    FocusZone.prototype._shouldInputLoseFocus = function (element, isForward) {\n        // If a tab was used, we want to focus on the next element.\n        if (!this._processingTabKey &&\n            element &&\n            element.type &&\n            ALLOWED_INPUT_TYPES.indexOf(element.type.toLowerCase()) > -1) {\n            var selectionStart = element.selectionStart;\n            var selectionEnd = element.selectionEnd;\n            var isRangeSelected = selectionStart !== selectionEnd;\n            var inputValue = element.value;\n            var isReadonly = element.readOnly;\n            // We shouldn't lose focus in the following cases:\n            // 1. There is range selected.\n            // 2. When selection start is larger than 0 and it is backward and not readOnly.\n            // 3. when selection start is not the end of length, it is forward and not readOnly.\n            // 4. We press any of the arrow keys when our handleTabKey isn't none or undefined (only losing focus if we hit\n            // tab) and if shouldInputLoseFocusOnArrowKey is defined, if scenario prefers to not loose the focus which is\n            // determined by calling the callback shouldInputLoseFocusOnArrowKey\n            if (isRangeSelected ||\n                (selectionStart > 0 && !isForward && !isReadonly) ||\n                (selectionStart !== inputValue.length && isForward && !isReadonly) ||\n                (!!this.props.handleTabKey &&\n                    !(this.props.shouldInputLoseFocusOnArrowKey && this.props.shouldInputLoseFocusOnArrowKey(element)))) {\n                return false;\n            }\n        }\n        return true;\n    };\n    FocusZone.prototype._shouldWrapFocus = function (element, noWrapDataAttribute) {\n        return this.props.checkForNoWrap ? shouldWrapFocus(element, noWrapDataAttribute) : true;\n    };\n    /**\n     * Returns true if the element is a descendant of the FocusZone through a React portal.\n     */\n    FocusZone.prototype._portalContainsElement = function (element) {\n        return element && !!this._root.current && portalContainsElement(element, this._root.current);\n    };\n    FocusZone.prototype._getDocument = function () {\n        return getDocument(this._root.current);\n    };\n    FocusZone.contextType = MergeStylesShadowRootContext;\n    FocusZone.defaultProps = {\n        isCircularNavigation: false,\n        direction: FocusZoneDirection.bidirectional,\n        shouldRaiseClicks: true,\n        // Hardcoding uncontrolled flag for proper interop with FluentUI V9.\n        'data-tabster': '{\"uncontrolled\": {}}',\n    };\n    return FocusZone;\n}(React.Component));\nexport { FocusZone };\n//# sourceMappingURL=FocusZone.js.map","import { concatStyleSets } from './concatStyleSets';\n/**\n * Concatenates style sets into one, but resolves functional sets using the given props.\n * @param styleProps - Props used to resolve functional sets.\n * @param allStyles - Style sets, which can be functions or objects.\n */\nexport function concatStyleSetsWithProps(styleProps) {\n    var allStyles = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        allStyles[_i - 1] = arguments[_i];\n    }\n    var result = [];\n    for (var _a = 0, allStyles_1 = allStyles; _a < allStyles_1.length; _a++) {\n        var styles = allStyles_1[_a];\n        if (styles) {\n            result.push(typeof styles === 'function' ? styles(styleProps) : styles);\n        }\n    }\n    if (result.length === 1) {\n        return result[0];\n    }\n    else if (result.length) {\n        // cliffkoh: I cannot figure out how to avoid the cast to any here.\n        // It is something to do with the use of Omit in IStyleSet.\n        // It might not be necessary once  Omit becomes part of lib.d.ts (when we remove our own Omit and rely on\n        // the official version).\n        return concatStyleSets.apply(void 0, result);\n    }\n    return {};\n}\n//# sourceMappingURL=concatStyleSetsWithProps.js.map","import * as React from 'react';\nimport { useConst } from './useConst';\nexport function useControllableValue(controlledValue, defaultUncontrolledValue, onChange) {\n    var _a = React.useState(defaultUncontrolledValue), value = _a[0], setValue = _a[1];\n    var isControlled = useConst(controlledValue !== undefined);\n    var currentValue = isControlled ? controlledValue : value;\n    // Duplicate the current value and onChange in refs so they're accessible from\n    // setValueOrCallOnChange without creating a new callback every time\n    var valueRef = React.useRef(currentValue);\n    var onChangeRef = React.useRef(onChange);\n    React.useEffect(function () {\n        valueRef.current = currentValue;\n        onChangeRef.current = onChange;\n    });\n    // To match the behavior of the setter returned by React.useState, this callback's identity\n    // should never change. This means it MUST NOT directly reference variables that can change.\n    var setValueOrCallOnChange = useConst(function () { return function (update, ev) {\n        // Assuming here that TValue is not a function, because a controllable value will typically\n        // be something a user can enter as input\n        var newValue = typeof update === 'function' ? update(valueRef.current) : update;\n        if (onChangeRef.current) {\n            onChangeRef.current(ev, newValue);\n        }\n        if (!isControlled) {\n            setValue(newValue);\n        }\n    }; });\n    return [currentValue, setValueOrCallOnChange];\n}\n//# sourceMappingURL=useControllableValue.js.map","import { getStyleOptions } from './StyleOptionsState';\nimport { Stylesheet } from './Stylesheet';\nimport { serializeRuleEntries } from './styleToClassName';\n/**\n * Registers a font face.\n * @public\n */\nexport function fontFace(font) {\n    var stylesheet = Stylesheet.getInstance();\n    var rule = serializeRuleEntries(getStyleOptions(), font);\n    var className = stylesheet.classNameFromKey(rule);\n    if (className) {\n        return;\n    }\n    var name = stylesheet.getClassName();\n    stylesheet.insertRule(\"@font-face{\".concat(rule, \"}\"), true);\n    stylesheet.cacheClassName(name, rule, [], ['font-face', rule]);\n}\n//# sourceMappingURL=fontFace.js.map","import * as React from 'react';\nimport { useConst } from './useConst';\n/**\n *  Returns a wrapper function for `setTimeout` which automatically handles disposal.\n */\nexport var useSetTimeout = function () {\n    var timeoutIds = useConst({});\n    // Cleanup function.\n    React.useEffect(function () { return function () {\n        for (var _i = 0, _a = Object.keys(timeoutIds); _i < _a.length; _i++) {\n            var id = _a[_i];\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            clearTimeout(id);\n        }\n    }; }, \n    // useConst ensures this will never change, but react-hooks/exhaustive-deps doesn't know that\n    [timeoutIds]);\n    // Return wrapper which will auto cleanup.\n    return useConst({\n        setTimeout: function (func, duration) {\n            var id = setTimeout(func, duration);\n            timeoutIds[id] = 1;\n            return id;\n        },\n        clearTimeout: function (id) {\n            delete timeoutIds[id];\n            clearTimeout(id);\n        },\n    });\n};\n//# sourceMappingURL=useSetTimeout.js.map","import * as React from 'react';\n/**\n * Creates a ref, and calls a callback whenever the ref changes to a non-null value. The callback can optionally return\n * a cleanup function that'll be called before the value changes, and when the ref is unmounted.\n *\n * This can be used to work around a limitation that useEffect cannot depend on `ref.current` (see\n * https://github.com/facebook/react/issues/14387#issuecomment-503616820).\n *\n * Usage example:\n * ```ts\n * const myRef = useRefEffect<HTMLElement>(element => {\n *  ...\n *  return () => { ... cleanup ... };\n * });\n * ```\n * ```jsx\n * <div ref={myRef} />\n * ```\n *\n * @param callback - Called whenever the ref's value changes to non-null. Can optionally return a cleanup function.\n * @param initial - (Optional) The initial value for the ref.\n *\n * @returns A function that should be called to set the ref's value. The object also has a `.current` member that can be\n * used to access the ref's value (like a normal RefObject). It can be hooked up to an element's `ref` property.\n */\nexport function useRefEffect(callback, initial) {\n    if (initial === void 0) { initial = null; }\n    var createRefCallback = function () {\n        var refCallback = function (value) {\n            if (data.ref.current !== value) {\n                if (data.cleanup) {\n                    data.cleanup();\n                    data.cleanup = undefined;\n                }\n                data.ref.current = value;\n                if (value !== null) {\n                    data.cleanup = data.callback(value);\n                }\n            }\n        };\n        refCallback.current = initial;\n        return refCallback;\n    };\n    var data = React.useRef({\n        ref: createRefCallback(),\n        callback: callback,\n    }).current;\n    data.callback = callback;\n    return data.ref;\n}\n//# sourceMappingURL=useRefEffect.js.map","import { __spreadArray } from \"tslib\";\nimport * as React from 'react';\n/**\n * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that\n * updates all provided refs\n * @param refs - Refs to collectively update with one ref value.\n * @returns A function with an attached \"current\" prop, so that it can be treated like a RefObject.\n */\nexport function useMergedRefs() {\n    var refs = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        refs[_i] = arguments[_i];\n    }\n    var mergedCallback = React.useCallback(function (value) {\n        // Update the \"current\" prop hanging on the function.\n        mergedCallback.current = value;\n        for (var _i = 0, refs_1 = refs; _i < refs_1.length; _i++) {\n            var ref = refs_1[_i];\n            if (typeof ref === 'function') {\n                ref(value);\n            }\n            else if (ref) {\n                // work around the immutability of the React.Ref type\n                ref.current = value;\n            }\n        }\n    }, __spreadArray([], refs, true));\n    return mergedCallback;\n}\n//# sourceMappingURL=useMergedRefs.js.map","export var GLOBAL_STYLESHEET_KEY = '__global__';\nexport var SHADOW_DOM_STYLESHEET_SETTING = '__shadow_dom_stylesheet__';\nexport var DEFAULT_SHADOW_CONFIG = {\n    stylesheetKey: GLOBAL_STYLESHEET_KEY,\n    inShadow: false,\n    window: undefined,\n    __isShadowConfig__: true,\n};\nexport var makeShadowConfig = function (stylesheetKey, inShadow, window) {\n    return {\n        stylesheetKey: stylesheetKey,\n        inShadow: inShadow,\n        window: window,\n        __isShadowConfig__: true,\n    };\n};\nexport var isShadowConfig = function (value) {\n    if (!(value && isRecord(value))) {\n        return false;\n    }\n    return value.__isShadowConfig__ === true;\n};\nfunction isRecord(value) {\n    return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n//# sourceMappingURL=shadowConfig.js.map","import { Async } from '@fluentui/utilities';\nimport * as React from 'react';\n/**\n * Hook to provide an Async instance that is automatically cleaned up on dismount.\n */\nexport function useAsync() {\n    var asyncRef = React.useRef();\n    if (!asyncRef.current) {\n        asyncRef.current = new Async();\n    }\n    React.useEffect(function () {\n        return function () {\n            var _a;\n            (_a = asyncRef.current) === null || _a === void 0 ? void 0 : _a.dispose();\n            asyncRef.current = undefined;\n        };\n    }, []);\n    return asyncRef.current;\n}\n//# sourceMappingURL=useAsync.js.map","import { isShadowConfig } from './shadowConfig';\n/**\n * Separates the classes and style objects. Any classes that are pre-registered\n * args are auto expanded into objects.\n */\nexport function extractStyleParts(sheet) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var classes = [];\n    var objects = [];\n    var stylesheet = sheet;\n    function _processArgs(argsList) {\n        for (var _i = 0, argsList_1 = argsList; _i < argsList_1.length; _i++) {\n            var arg = argsList_1[_i];\n            if (arg && !isShadowConfig(arg)) {\n                if (typeof arg === 'string') {\n                    if (arg.indexOf(' ') >= 0) {\n                        _processArgs(arg.split(' '));\n                    }\n                    else {\n                        var translatedArgs = stylesheet.argsFromClassName(arg);\n                        if (translatedArgs) {\n                            _processArgs(translatedArgs);\n                        }\n                        else {\n                            // Avoid adding the same class twice.\n                            if (classes.indexOf(arg) === -1) {\n                                classes.push(arg);\n                            }\n                        }\n                    }\n                }\n                else if (Array.isArray(arg)) {\n                    _processArgs(arg);\n                }\n                else if (typeof arg === 'object') {\n                    objects.push(arg);\n                }\n            }\n        }\n    }\n    _processArgs(args);\n    return {\n        classes: classes,\n        objects: objects,\n    };\n}\n//# sourceMappingURL=extractStyleParts.js.map","import { extractStyleParts } from './extractStyleParts';\nimport { isShadowConfig } from './shadowConfig';\nimport { getStyleOptions } from './StyleOptionsState';\nimport { Stylesheet } from './Stylesheet';\nimport { styleToClassName } from './styleToClassName';\n/**\n * Concatenation helper, which can merge class names together. Skips over falsey values.\n *\n * @public\n */\nexport function mergeStyles() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return mergeCss(args, getStyleOptions());\n}\n/**\n * Concatenation helper, which can merge class names together. Skips over falsey values.\n * Accepts a set of options that will be used when calculating styles.\n *\n * @public\n */\nexport function mergeCss(args, options) {\n    var styleArgs = args instanceof Array ? args : [args];\n    var opts = options || {};\n    var hasShadowConfig = isShadowConfig(styleArgs[0]);\n    if (hasShadowConfig) {\n        opts.shadowConfig = styleArgs[0];\n    }\n    opts.stylesheet = Stylesheet.getInstance(opts.shadowConfig);\n    var _a = extractStyleParts(opts.stylesheet, styleArgs), classes = _a.classes, objects = _a.objects;\n    if (objects.length) {\n        classes.push(styleToClassName(opts, objects));\n    }\n    return classes.join(' ');\n}\n//# sourceMappingURL=mergeStyles.js.map","import { __assign } from \"tslib\";\nimport { GLOBAL_STYLESHEET_KEY, SHADOW_DOM_STYLESHEET_SETTING } from './shadowConfig';\nexport var InjectionMode = {\n    /**\n     * Avoids style injection, use getRules() to read the styles.\n     */\n    none: 0,\n    /**\n     * Inserts rules using the insertRule api.\n     */\n    insertNode: 1,\n    /**\n     * Appends rules using appendChild.\n     */\n    appendChild: 2,\n};\nexport var STYLESHEET_SETTING = '__stylesheet__';\n/**\n * MSIE 11 doesn't cascade styles based on DOM ordering, but rather on the order that each style node\n * is created. As such, to maintain consistent priority, IE11 should reuse a single style node.\n */\nvar REUSE_STYLE_NODE = typeof navigator !== 'undefined' && /rv:11.0/.test(navigator.userAgent);\nvar _global = {};\n// Grab window.\ntry {\n    // Why the cast?\n    // if compiled/type checked in same program with `@fluentui/font-icons-mdl2` which extends `Window` on global\n    // ( check packages/font-icons-mdl2/src/index.ts ) the definitions don't match! Thus the need of this extra assertion\n    _global = (window || {});\n}\ncatch (_a) {\n    /* leave as blank object */\n}\nvar _stylesheet;\n/**\n * Represents the state of styles registered in the page. Abstracts\n * the surface for adding styles to the stylesheet, exposes helpers\n * for reading the styles registered in server rendered scenarios.\n *\n * @public\n */\nvar Stylesheet = /** @class */ (function () {\n    function Stylesheet(config, serializedStylesheet) {\n        var _a, _b, _c, _d, _e, _f;\n        this._rules = [];\n        this._preservedRules = [];\n        this._counter = 0;\n        this._keyToClassName = {};\n        this._onInsertRuleCallbacks = [];\n        this._onResetCallbacks = [];\n        this._classNameToArgs = {};\n        // If there is no document we won't have an element to inject into.\n        this._config = __assign({ injectionMode: typeof document === 'undefined' ? InjectionMode.none : InjectionMode.insertNode, defaultPrefix: 'css', namespace: undefined, cspSettings: undefined }, config);\n        this._classNameToArgs = (_a = serializedStylesheet === null || serializedStylesheet === void 0 ? void 0 : serializedStylesheet.classNameToArgs) !== null && _a !== void 0 ? _a : this._classNameToArgs;\n        this._counter = (_b = serializedStylesheet === null || serializedStylesheet === void 0 ? void 0 : serializedStylesheet.counter) !== null && _b !== void 0 ? _b : this._counter;\n        this._keyToClassName = (_d = (_c = this._config.classNameCache) !== null && _c !== void 0 ? _c : serializedStylesheet === null || serializedStylesheet === void 0 ? void 0 : serializedStylesheet.keyToClassName) !== null && _d !== void 0 ? _d : this._keyToClassName;\n        this._preservedRules = (_e = serializedStylesheet === null || serializedStylesheet === void 0 ? void 0 : serializedStylesheet.preservedRules) !== null && _e !== void 0 ? _e : this._preservedRules;\n        this._rules = (_f = serializedStylesheet === null || serializedStylesheet === void 0 ? void 0 : serializedStylesheet.rules) !== null && _f !== void 0 ? _f : this._rules;\n    }\n    /**\n     * Gets the singleton instance.\n     */\n    Stylesheet.getInstance = function (shadowConfig) {\n        _stylesheet = _global[STYLESHEET_SETTING];\n        if (_global[SHADOW_DOM_STYLESHEET_SETTING]) {\n            return _global[SHADOW_DOM_STYLESHEET_SETTING].getInstance(shadowConfig);\n        }\n        if (!_stylesheet || (_stylesheet._lastStyleElement && _stylesheet._lastStyleElement.ownerDocument !== document)) {\n            var fabricConfig = (_global === null || _global === void 0 ? void 0 : _global.FabricConfig) || {};\n            var stylesheet = new Stylesheet(fabricConfig.mergeStyles, fabricConfig.serializedStylesheet);\n            _stylesheet = stylesheet;\n            _global[STYLESHEET_SETTING] = stylesheet;\n        }\n        return _stylesheet;\n    };\n    /**\n     * Serializes the Stylesheet instance into a format which allows rehydration on creation.\n     * @returns string representation of `ISerializedStylesheet` interface.\n     */\n    Stylesheet.prototype.serialize = function () {\n        return JSON.stringify({\n            classNameToArgs: this._classNameToArgs,\n            counter: this._counter,\n            keyToClassName: this._keyToClassName,\n            preservedRules: this._preservedRules,\n            rules: this._rules,\n        });\n    };\n    /**\n     * Configures the stylesheet.\n     */\n    Stylesheet.prototype.setConfig = function (config) {\n        this._config = __assign(__assign({}, this._config), config);\n    };\n    /**\n     * Configures a reset callback.\n     *\n     * @param callback - A callback which will be called when the Stylesheet is reset.\n     * @returns function which when called un-registers provided callback.\n     */\n    Stylesheet.prototype.onReset = function (callback) {\n        var _this = this;\n        this._onResetCallbacks.push(callback);\n        return function () {\n            _this._onResetCallbacks = _this._onResetCallbacks.filter(function (cb) { return cb !== callback; });\n        };\n    };\n    /**\n     * Configures an insert rule callback.\n     *\n     * @param callback - A callback which will be called when a rule is inserted.\n     * @returns function which when called un-registers provided callback.\n     */\n    Stylesheet.prototype.onInsertRule = function (callback) {\n        var _this = this;\n        this._onInsertRuleCallbacks.push(callback);\n        return function () {\n            _this._onInsertRuleCallbacks = _this._onInsertRuleCallbacks.filter(function (cb) { return cb !== callback; });\n        };\n    };\n    /**\n     * Generates a unique classname.\n     *\n     * @param displayName - Optional value to use as a prefix.\n     */\n    Stylesheet.prototype.getClassName = function (displayName) {\n        var namespace = this._config.namespace;\n        var prefix = displayName || this._config.defaultPrefix;\n        return \"\".concat(namespace ? namespace + '-' : '').concat(prefix, \"-\").concat(this._counter++);\n    };\n    /**\n     * Used internally to cache information about a class which was\n     * registered with the stylesheet.\n     */\n    Stylesheet.prototype.cacheClassName = function (className, key, args, rules) {\n        this._keyToClassName[this._getCacheKey(key)] = className;\n        this._classNameToArgs[className] = {\n            args: args,\n            rules: rules,\n        };\n    };\n    /**\n     * Gets the appropriate classname given a key which was previously\n     * registered using cacheClassName.\n     */\n    Stylesheet.prototype.classNameFromKey = function (key) {\n        return this._keyToClassName[this._getCacheKey(key)];\n    };\n    /**\n     * Gets all classnames cache with the stylesheet.\n     */\n    Stylesheet.prototype.getClassNameCache = function () {\n        return this._keyToClassName;\n    };\n    /**\n     * Gets the arguments associated with a given classname which was\n     * previously registered using cacheClassName.\n     */\n    Stylesheet.prototype.argsFromClassName = function (className) {\n        var entry = this._classNameToArgs[className];\n        return entry && entry.args;\n    };\n    /**\n     * Gets the rules associated with a given classname which was\n     * previously registered using cacheClassName.\n     */\n    Stylesheet.prototype.insertedRulesFromClassName = function (className) {\n        var entry = this._classNameToArgs[className];\n        return entry && entry.rules;\n    };\n    /**\n     * Inserts a css rule into the stylesheet.\n     * @param preserve - Preserves the rule beyond a reset boundary.\n     */\n    Stylesheet.prototype.insertRule = function (rule, preserve, stylesheetKey) {\n        if (stylesheetKey === void 0) { stylesheetKey = GLOBAL_STYLESHEET_KEY; }\n        var injectionMode = this._config.injectionMode;\n        var element = injectionMode !== InjectionMode.none ? this._getStyleElement() : undefined;\n        if (preserve) {\n            this._preservedRules.push(rule);\n        }\n        if (element) {\n            switch (injectionMode) {\n                case InjectionMode.insertNode:\n                    this._insertRuleIntoSheet(element.sheet, rule);\n                    break;\n                case InjectionMode.appendChild:\n                    element.appendChild(document.createTextNode(rule));\n                    break;\n            }\n        }\n        else {\n            this._rules.push(rule);\n        }\n        // eslint-disable-next-line deprecation/deprecation\n        if (this._config.onInsertRule) {\n            // eslint-disable-next-line deprecation/deprecation\n            this._config.onInsertRule(rule);\n        }\n        this._onInsertRuleCallbacks.forEach(function (callback) {\n            return callback({ key: stylesheetKey, sheet: (element ? element.sheet : undefined), rule: rule });\n        });\n    };\n    /**\n     * Gets all rules registered with the stylesheet; only valid when\n     * using InsertionMode.none.\n     */\n    Stylesheet.prototype.getRules = function (includePreservedRules) {\n        return (includePreservedRules ? this._preservedRules.join('') : '') + this._rules.join('');\n    };\n    /**\n     * Resets the internal state of the stylesheet. Only used in server\n     * rendered scenarios where we're using InsertionMode.none.\n     */\n    Stylesheet.prototype.reset = function () {\n        this._rules = [];\n        this._counter = 0;\n        this._classNameToArgs = {};\n        this._keyToClassName = {};\n        this._onResetCallbacks.forEach(function (callback) { return callback(); });\n    };\n    // Forces the regeneration of incoming styles without totally resetting the stylesheet.\n    Stylesheet.prototype.resetKeys = function () {\n        this._keyToClassName = {};\n    };\n    Stylesheet.prototype._createStyleElement = function () {\n        var _a;\n        var doc = ((_a = this._config.window) === null || _a === void 0 ? void 0 : _a.document) || document;\n        var head = doc.head;\n        var styleElement = doc.createElement('style');\n        var nodeToInsertBefore = null;\n        styleElement.setAttribute('data-merge-styles', 'true');\n        var cspSettings = this._config.cspSettings;\n        if (cspSettings) {\n            if (cspSettings.nonce) {\n                styleElement.setAttribute('nonce', cspSettings.nonce);\n            }\n        }\n        if (this._lastStyleElement) {\n            // If the `nextElementSibling` is null, then the insertBefore will act as a regular append.\n            // https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore#Syntax\n            nodeToInsertBefore = this._lastStyleElement.nextElementSibling;\n        }\n        else {\n            var placeholderStyleTag = this._findPlaceholderStyleTag();\n            if (placeholderStyleTag) {\n                nodeToInsertBefore = placeholderStyleTag.nextElementSibling;\n            }\n            else {\n                nodeToInsertBefore = head.childNodes[0];\n            }\n        }\n        head.insertBefore(styleElement, head.contains(nodeToInsertBefore) ? nodeToInsertBefore : null);\n        this._lastStyleElement = styleElement;\n        return styleElement;\n    };\n    Stylesheet.prototype._insertRuleIntoSheet = function (sheet, rule) {\n        if (!sheet) {\n            return false;\n        }\n        try {\n            sheet.insertRule(rule, sheet.cssRules.length);\n            return true;\n        }\n        catch (e) {\n            // The browser will throw exceptions on unsupported rules (such as a moz prefix in webkit.)\n            // We need to swallow the exceptions for this scenario, otherwise we'd need to filter\n            // which could be slower and bulkier.\n        }\n        return false;\n    };\n    Stylesheet.prototype._getCacheKey = function (key) {\n        return key;\n    };\n    Stylesheet.prototype._getStyleElement = function () {\n        var _this = this;\n        if (!this._styleElement) {\n            this._styleElement = this._createStyleElement();\n            if (!REUSE_STYLE_NODE) {\n                // Reset the style element on the next frame.\n                var win = this._config.window || window;\n                win.requestAnimationFrame(function () {\n                    _this._styleElement = undefined;\n                });\n            }\n        }\n        return this._styleElement;\n    };\n    Stylesheet.prototype._findPlaceholderStyleTag = function () {\n        var head = document.head;\n        if (head) {\n            return head.querySelector('style[data-merge-styles]');\n        }\n        return null;\n    };\n    return Stylesheet;\n}());\nexport { Stylesheet };\n//# sourceMappingURL=Stylesheet.js.map","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { warn, warnControlledUsage, warnConditionallyRequiredProps, warnDeprecations, warnMutuallyExclusive, } from '@fluentui/utilities';\nimport { usePrevious } from './usePrevious';\nimport { useConst } from './useConst';\nvar warningId = 0;\n/**\n * Only in development mode, display console warnings when certain conditions are met.\n * Note that all warnings except `controlledUsage` will only be shown on first render\n * (new `controlledUsage` warnings may be shown later due to prop changes).\n */\nexport function useWarnings(options) {\n    if (process.env.NODE_ENV !== 'production') {\n        var name_1 = options.name, props = options.props, _a = options.other, other = _a === void 0 ? [] : _a, conditionallyRequired = options.conditionallyRequired, deprecations = options.deprecations, mutuallyExclusive = options.mutuallyExclusive, controlledUsage = options.controlledUsage;\n        /* eslint-disable react-hooks/rules-of-hooks -- build-time conditional */\n        var hasWarnedRef = React.useRef(false);\n        var componentId = useConst(function () { return \"useWarnings_\".concat(warningId++); });\n        var oldProps = usePrevious(props);\n        /* eslint-enable react-hooks/rules-of-hooks */\n        // Warn synchronously (not in useEffect) on first render to make debugging easier.\n        if (!hasWarnedRef.current) {\n            hasWarnedRef.current = true;\n            for (var _i = 0, other_1 = other; _i < other_1.length; _i++) {\n                var warning = other_1[_i];\n                warn(warning);\n            }\n            if (conditionallyRequired) {\n                for (var _b = 0, conditionallyRequired_1 = conditionallyRequired; _b < conditionallyRequired_1.length; _b++) {\n                    var req = conditionallyRequired_1[_b];\n                    warnConditionallyRequiredProps(name_1, props, req.requiredProps, req.conditionalPropName, req.condition);\n                }\n            }\n            deprecations && warnDeprecations(name_1, props, deprecations);\n            mutuallyExclusive && warnMutuallyExclusive(name_1, props, mutuallyExclusive);\n        }\n        // Controlled usage warnings may be displayed on either first or subsequent renders due to\n        // prop changes. Note that it's safe to run this synchronously (not in useEffect) even in\n        // concurrent mode because `warnControlledUsage` internally tracks which warnings have been\n        // displayed for each component instance (so nothing will be displayed twice).\n        controlledUsage && warnControlledUsage(__assign(__assign({}, controlledUsage), { componentId: componentId, props: props, componentName: name_1, oldProps: oldProps }));\n    }\n}\n//# sourceMappingURL=useWarnings.js.map","/**\n * {@docCategory FocusZone}\n */\nexport var FocusZoneTabbableElements = {\n    /** Tabbing is not allowed */\n    none: 0,\n    /** All tabbing action is allowed */\n    all: 1,\n    /** Tabbing is allowed only on input elements */\n    inputOnly: 2,\n};\n/**\n * {@docCategory FocusZone}\n */\nexport var FocusZoneDirection;\n(function (FocusZoneDirection) {\n    /** Only react to up/down arrows. */\n    FocusZoneDirection[FocusZoneDirection[\"vertical\"] = 0] = \"vertical\";\n    /** Only react to left/right arrows. */\n    FocusZoneDirection[FocusZoneDirection[\"horizontal\"] = 1] = \"horizontal\";\n    /** React to all arrows. */\n    FocusZoneDirection[FocusZoneDirection[\"bidirectional\"] = 2] = \"bidirectional\";\n    /**\n     * React to all arrows. Navigate next item in DOM on right/down arrow keys and previous - left/up arrow keys.\n     * Right and Left arrow keys are swapped in RTL mode.\n     */\n    FocusZoneDirection[FocusZoneDirection[\"domOrder\"] = 3] = \"domOrder\";\n})(FocusZoneDirection || (FocusZoneDirection = {}));\n//# sourceMappingURL=FocusZone.types.js.map"],"sourceRoot":""}