Initial commit

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/Tab.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Tab", {
+    enumerable: true,
+    get: function() {
+        return Tab;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useTab = require("./useTab");
+const _renderTab = require("./renderTab");
+const _useTabStylesstyles = require("./useTabStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const Tab = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useTab.useTab_unstable)(props, ref);
+    (0, _useTabStylesstyles.useTabStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useTabStyles_unstable')(state);
+    return (0, _renderTab.renderTab_unstable)(state);
+});
+Tab.displayName = 'Tab';

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/Tab.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tab/Tab.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useTab_unstable } from './useTab';\nimport { renderTab_unstable } from './renderTab';\nimport { useTabStyles_unstable } from './useTabStyles.styles';\nimport type { TabProps } from './Tab.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * A tab provides a selectable item in a tab list.\n */\nexport const Tab: ForwardRefComponent<TabProps> = React.forwardRef((props, ref) => {\n  const state = useTab_unstable(props, ref);\n\n  useTabStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useTabStyles_unstable')(state);\n\n  return renderTab_unstable(state);\n});\n\nTab.displayName = 'Tab';\n"],"names":["Tab","React","forwardRef","props","ref","state","useTab_unstable","useTabStyles_unstable","useCustomStyleHook_unstable","renderTab_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;wBACS;2BACG;oCACG;qCAGM;AAKrC,MAAMA,MAAAA,WAAAA,GAAqCC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACzE,MAAMC,QAAQC,IAAAA,uBAAAA,EAAgBH,OAAOC;IAErCG,IAAAA,yCAAAA,EAAsBF;IAEtBG,IAAAA,gDAAAA,EAA4B,yBAAyBH;IAErD,OAAOI,IAAAA,6BAAAA,EAAmBJ;AAC5B;AAEAL,IAAIU,WAAW,GAAG"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/Tab.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering Tab
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/Tab.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tab/Tab.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\n/**\n * Any value that identifies a specific tab.\n */\nexport type TabValue = unknown;\n\nexport type TabSlots = {\n  /**\n   * Root of the component.\n   */\n  root: Slot<'button'>;\n\n  /**\n   * Icon that renders before the content.\n   */\n  icon?: Slot<'span'>;\n\n  /**\n   * Component children are placed in this slot\n   * Avoid using the `children` property in this slot in favour of Component children whenever possible.\n   */\n  content: NonNullable<Slot<'span'>>;\n};\n\nexport type TabInternalSlots = TabSlots & {\n  contentReservedSpace?: Slot<'span'>;\n};\n\n/**\n * Tab Props\n */\nexport type TabProps = Omit<ComponentProps<Partial<TabSlots>>, 'content'> &\n  Pick<Partial<TabSlots>, 'content'> & {\n    /**\n     * A tab can be set to disable interaction.\n     * @default false\n     */\n    disabled?: boolean;\n    /**\n     * The value that identifies this tab when selected.\n     */\n    value: TabValue;\n  };\n\n/**\n * State used in rendering Tab\n */\nexport type TabState = ComponentState<TabInternalSlots> &\n  Pick<TabProps, 'value'> &\n  Required<Pick<TabProps, 'disabled'>> & {\n    /**\n     * A tab supports 'transparent', 'subtle', `subtle-circular` and `filled-circular` appearance.\n     */\n    appearance?: 'transparent' | 'subtle' | 'subtle-circular' | 'filled-circular';\n\n    /**\n     * A tab can have only an icon slot filled and no content.\n     */\n    iconOnly: boolean;\n    /**\n     * If this tab is selected\n     */\n    selected: boolean;\n    /**\n     * When defined, tab content with selected style is rendered hidden to reserve space.\n     * This keeps consistent content size between unselected and selected states.\n     *\n     * @deprecated - use `contentReservedSpace` internal slot instead.\n     */\n    contentReservedSpaceClassName?: string;\n    /**\n     * A tab can be either 'small', 'medium', or 'large' size.\n     */\n    size: 'small' | 'medium' | 'large';\n    /**\n     * A tab can arrange its content based on if the tabs in the list are arranged vertically.\n     */\n    vertical: boolean;\n  };\n"],"names":[],"rangeMappings":";;","mappings":"AA6CA;;CAEC"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Tab: function() {
+        return _Tab.Tab;
+    },
+    renderTab_unstable: function() {
+        return _renderTab.renderTab_unstable;
+    },
+    tabClassNames: function() {
+        return _useTabStylesstyles.tabClassNames;
+    },
+    useTabAnimatedIndicatorStyles_unstable: function() {
+        return _useTabAnimatedIndicatorstyles.useTabAnimatedIndicatorStyles_unstable;
+    },
+    useTabButtonStyles_unstable: function() {
+        return _useTabStylesstyles.useTabButtonStyles_unstable;
+    },
+    useTabContentStyles_unstable: function() {
+        return _useTabStylesstyles.useTabContentStyles_unstable;
+    },
+    useTabIndicatorStyles_unstable: function() {
+        return _useTabStylesstyles.useTabIndicatorStyles_unstable;
+    },
+    useTabStyles_unstable: function() {
+        return _useTabStylesstyles.useTabStyles_unstable;
+    },
+    useTab_unstable: function() {
+        return _useTab.useTab_unstable;
+    }
+});
+const _Tab = require("./Tab");
+const _renderTab = require("./renderTab");
+const _useTab = require("./useTab");
+const _useTabStylesstyles = require("./useTabStyles.styles");
+const _useTabAnimatedIndicatorstyles = require("./useTabAnimatedIndicator.styles");

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tab/index.ts"],"sourcesContent":["export { Tab } from './Tab';\nexport type { TabInternalSlots, TabProps, TabSlots, TabState, TabValue } from './Tab.types';\nexport { renderTab_unstable } from './renderTab';\nexport { useTab_unstable } from './useTab';\nexport {\n  tabClassNames,\n  useTabButtonStyles_unstable,\n  useTabContentStyles_unstable,\n  useTabIndicatorStyles_unstable,\n  useTabStyles_unstable,\n} from './useTabStyles.styles';\nexport { useTabAnimatedIndicatorStyles_unstable } from './useTabAnimatedIndicator.styles';\n"],"names":["Tab","renderTab_unstable","tabClassNames","useTabAnimatedIndicatorStyles_unstable","useTabButtonStyles_unstable","useTabContentStyles_unstable","useTabIndicatorStyles_unstable","useTabStyles_unstable","useTab_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,GAAG;eAAHA,QAAG;;IAEHC,kBAAkB;eAAlBA,6BAAkB;;IAGzBC,aAAa;eAAbA,iCAAa;;IAMNC,sCAAsC;eAAtCA,qEAAsC;;IAL7CC,2BAA2B;eAA3BA,+CAA2B;;IAC3BC,4BAA4B;eAA5BA,gDAA4B;;IAC5BC,8BAA8B;eAA9BA,kDAA8B;;IAC9BC,qBAAqB;eAArBA,yCAAqB;;IANdC,eAAe;eAAfA,uBAAe;;;qBAHJ;2BAEe;wBACH;oCAOzB;+CACgD"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/renderTab.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderTab_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderTab_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderTab_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.icon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.icon, {}),
+            !state.iconOnly && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.content, {}),
+            state.contentReservedSpace && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.contentReservedSpace, {})
+        ]
+    });
+};

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/renderTab.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tab/renderTab.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { TabState, TabInternalSlots } from './Tab.types';\n\n/**\n * Render the final JSX of Tab\n */\nexport const renderTab_unstable = (state: TabState) => {\n  assertSlots<TabInternalSlots>(state);\n\n  return (\n    <state.root>\n      {state.icon && <state.icon />}\n      {!state.iconOnly && <state.content />}\n      {state.contentReservedSpace && <state.contentReservedSpace />}\n    </state.root>\n  );\n};\n"],"names":["renderTab_unstable","state","assertSlots","_jsxs","root","icon","_jsx","iconOnly","content","contentReservedSpace"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;4BAPb;gCAC4B;AAMrB,MAAMA,qBAAqB,CAACC;IACjCC,IAAAA,2BAAAA,EAA8BD;IAE9B,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACF,MAAMG,IAAI,EAAA;;YACRH,MAAMI,IAAI,IAAA,WAAA,GAAIC,IAAAA,eAAA,EAACL,MAAMI,IAAI,EAAA,CAAA;YACzB,CAACJ,MAAMM,QAAQ,IAAA,WAAA,GAAID,IAAAA,eAAA,EAACL,MAAMO,OAAO,EAAA,CAAA;YACjCP,MAAMQ,oBAAoB,IAAA,WAAA,GAAIH,IAAAA,eAAA,EAACL,MAAMQ,oBAAoB,EAAA,CAAA;;;AAGhE"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/useTab.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTab_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTab_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reacttabster = require("@fluentui/react-tabster");
+const _reactutilities = require("@fluentui/react-utilities");
+const _TabListContext = require("../TabList/TabListContext");
+const useTab_unstable = (props, ref)=>{
+    const { content, disabled: tabDisabled = false, icon, onClick, onFocus, value } = props;
+    const appearance = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.appearance);
+    const reserveSelectedTabSpace = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.reserveSelectedTabSpace);
+    const selectTabOnFocus = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.selectTabOnFocus);
+    const listDisabled = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.disabled);
+    const selected = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.selectedValue === value);
+    const onRegister = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.onRegister);
+    const onUnregister = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.onUnregister);
+    const onSelect = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.onSelect);
+    const size = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.size);
+    const vertical = (0, _TabListContext.useTabListContext_unstable)((ctx)=>!!ctx.vertical);
+    const disabled = listDisabled || tabDisabled;
+    const innerRef = _react.useRef(null);
+    const onSelectCallback = (event)=>onSelect(event, {
+            value
+        });
+    const onTabClick = (0, _reactutilities.useEventCallback)((0, _reactutilities.mergeCallbacks)(onClick, onSelectCallback));
+    const onTabFocus = (0, _reactutilities.useEventCallback)((0, _reactutilities.mergeCallbacks)(onFocus, onSelectCallback));
+    const focusProps = (0, _reacttabster.useTabsterAttributes)({
+        focusable: {
+            isDefault: selected
+        }
+    });
+    _react.useEffect(()=>{
+        onRegister({
+            value,
+            ref: innerRef
+        });
+        return ()=>{
+            onUnregister({
+                value,
+                ref: innerRef
+            });
+        };
+    }, [
+        onRegister,
+        onUnregister,
+        innerRef,
+        value
+    ]);
+    const iconSlot = _reactutilities.slot.optional(icon, {
+        elementType: 'span'
+    });
+    const contentSlot = _reactutilities.slot.always(content, {
+        defaultProps: {
+            children: props.children
+        },
+        elementType: 'span'
+    });
+    const contentReservedSpace = content && typeof content === 'object' ? (0, _reactutilities.omit)(content, [
+        'ref'
+    ]) : content;
+    const iconOnly = Boolean((iconSlot === null || iconSlot === void 0 ? void 0 : iconSlot.children) && !contentSlot.children);
+    return {
+        components: {
+            root: 'button',
+            icon: 'span',
+            content: 'span',
+            contentReservedSpace: 'span'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('button', {
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLButtonElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: (0, _reactutilities.useMergedRefs)(ref, innerRef),
+            role: 'tab',
+            type: 'button',
+            // aria-selected undefined indicates it is not selectable
+            // according to https://www.w3.org/TR/wai-aria-1.1/#aria-selected
+            'aria-selected': disabled ? undefined : `${selected}`,
+            ...focusProps,
+            ...props,
+            disabled,
+            onClick: onTabClick,
+            onFocus: selectTabOnFocus ? onTabFocus : onFocus
+        }), {
+            elementType: 'button'
+        }),
+        icon: iconSlot,
+        iconOnly,
+        content: contentSlot,
+        contentReservedSpace: _reactutilities.slot.optional(contentReservedSpace, {
+            renderByDefault: !selected && !iconOnly && reserveSelectedTabSpace,
+            defaultProps: {
+                children: props.children
+            },
+            elementType: 'span'
+        }),
+        appearance,
+        disabled,
+        selected,
+        size,
+        value,
+        vertical
+    };
+};

node_modules/@fluentui/react-tabs/lib-commonjs/components/Tab/useTabAnimatedIndicator.styles.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTabAnimatedIndicatorStyles_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTabAnimatedIndicatorStyles_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _react1 = require("@griffel/react");
+const _TabListContext = require("../TabList/TabListContext");
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const tabIndicatorCssVars_unstable = {
+    offsetVar: '--fui-Tab__indicator--offset',
+    scaleVar: '--fui-Tab__indicator--scale'
+};
+const useActiveIndicatorStyles = /*#__PURE__*/ (0, _react1.__styles)({
+    base: {
+        B68tc82: 0,
+        Bmxbyg5: 0,
+        Bpg54ce: "f1gl81tg"
+    },
+    animated: {
+        Ba2ppi3: "fhwpy7i",
+        F2fol1: "f6zz20j",
+        B1dyfl9: "f1ai4sc1",
+        B0vmy72: "f9qxlq5",
+        u9bimw: "f1aql376"
+    },
+    horizontal: {
+        sjv3b2: [
+            "fug4aj8",
+            "f1i5xzg7"
+        ],
+        b1kco5: "f1q7ujh"
+    },
+    vertical: {
+        sjv3b2: "f1hqboyk",
+        b1kco5: "f1dxupa6"
+    }
+}, {
+    d: [
+        [
+            ".f1gl81tg{overflow:visible;}",
+            {
+                p: -1
+            }
+        ],
+        ".fhwpy7i::after{transition-property:transform;}",
+        ".f6zz20j::after{transition-duration:var(--durationSlow);}",
+        ".f1ai4sc1::after{transition-timing-function:var(--curveDecelerateMax);}",
+        ".fug4aj8::after{transform-origin:left;}",
+        ".f1i5xzg7::after{transform-origin:right;}",
+        ".f1q7ujh::after{transform:translateX(var(--fui-Tab__indicator--offset)) scaleX(var(--fui-Tab__indicator--scale));}",
+        ".f1hqboyk::after{transform-origin:top;}",
+        ".f1dxupa6::after{transform:translateY(var(--fui-Tab__indicator--offset)) scaleY(var(--fui-Tab__indicator--scale));}"
+    ],
+    m: [
+        [
+            "@media (prefers-reduced-motion: reduce){.f9qxlq5::after{transition-property:none;}}",
+            {
+                m: "(prefers-reduced-motion: reduce)"
+            }
+        ],
+        [
+            "@media (prefers-reduced-motion: reduce){.f1aql376::after{transition-duration:0.01ms;}}",
+            {
+                m: "(prefers-reduced-motion: reduce)"
+            }
+        ]
+    ]
+});
+const calculateTabRect = (element)=>{
+    if (element) {
+        var _element_parentElement;
+        const parentRect = ((_element_parentElement = element.parentElement) === null || _element_parentElement === void 0 ? void 0 : _element_parentElement.getBoundingClientRect()) || {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        };
+        const tabRect = element.getBoundingClientRect();
+        return {
+            x: tabRect.x - parentRect.x,
+            y: tabRect.y - parentRect.y,
+            width: tabRect.width,
+            height: tabRect.height
+        };
+    }
+    return undefined;
+};
+const getRegisteredTabRect = (registeredTabs, value)=>{
+    var _registeredTabs_JSON_stringify;
+    const element = isValueDefined(value) ? (_registeredTabs_JSON_stringify = registeredTabs[JSON.stringify(value)]) === null || _registeredTabs_JSON_stringify === void 0 ? void 0 : _registeredTabs_JSON_stringify.ref.current : undefined;
+    return element ? calculateTabRect(element) : undefined;
+};
+// eslint-disable-next-line eqeqeq
+const isValueDefined = (value)=>value != null;
+const useTabAnimatedIndicatorStyles_unstable = (state)=>{
+    const { disabled, selected, vertical } = state;
+    const activeIndicatorStyles = useActiveIndicatorStyles();
+    const [lastAnimatedFrom, setLastAnimatedFrom] = _react.useState();
+    const [animationValues, setAnimationValues] = _react.useState({
+        offset: 0,
+        scale: 1
+    });
+    const getRegisteredTabs = (0, _TabListContext.useTabListContext_unstable)((ctx)=>ctx.getRegisteredTabs);
+    _react.useEffect(()=>{
+        if (isValueDefined(lastAnimatedFrom)) {
+            setAnimationValues({
+                offset: 0,
+                scale: 1
+            });
+        }
+    }, [
+        lastAnimatedFrom
+    ]);
+    if (selected) {
+        const { previousSelectedValue, selectedValue, registeredTabs } = getRegisteredTabs();
+        if (isValueDefined(previousSelectedValue) && lastAnimatedFrom !== previousSelectedValue) {
+            const previousSelectedTabRect = getRegisteredTabRect(registeredTabs, previousSelectedValue);
+            const selectedTabRect = getRegisteredTabRect(registeredTabs, selectedValue);
+            if (selectedTabRect && previousSelectedTabRect) {
+                const offset = vertical ? previousSelectedTabRect.y - selectedTabRect.y : previousSelectedTabRect.x - selectedTabRect.x;
+                const scale = vertical ? previousSelectedTabRect.height / selectedTabRect.height : previousSelectedTabRect.width / selectedTabRect.width;
+                setAnimationValues({
+                    offset,
+                    scale
+                });
+                setLastAnimatedFrom(previousSelectedValue);
+            }
+        }
+    } else if (isValueDefined(lastAnimatedFrom)) {
+        // need to clear the last animated from so that if this tab is selected again
+        // from the same previous tab as last time, that animation still happens.
+        setLastAnimatedFrom(undefined);
+    }
+    // do not apply any animation if the tab is disabled
+    if (disabled) {
+        return state;
+    }
+    // the animation should only happen as the selection indicator returns to its
+    // original position and not when set at the previous tabs position.
+    const animating = animationValues.offset === 0 && animationValues.scale === 1;
+    state.root.className = (0, _react1.mergeClasses)(state.root.className, selected && activeIndicatorStyles.base, selected && animating && activeIndicatorStyles.animated, selected && (vertical ? activeIndicatorStyles.vertical : activeIndicatorStyles.horizontal));
+    const rootCssVars = {
+        [tabIndicatorCssVars_unstable.offsetVar]: `${animationValues.offset}px`,
+        [tabIndicatorCssVars_unstable.scaleVar]: `${animationValues.scale}`
+    };
+    state.root.style = {
+        ...rootCssVars,
+        ...state.root.style
+    };
+    return state;
+};

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/TabList.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TabList", {
+    enumerable: true,
+    get: function() {
+        return TabList;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useTabList = require("./useTabList");
+const _renderTabList = require("./renderTabList");
+const _useTabListStylesstyles = require("./useTabListStyles.styles");
+const _useTabListContextValues = require("./useTabListContextValues");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const TabList = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useTabList.useTabList_unstable)(props, ref);
+    const contextValues = (0, _useTabListContextValues.useTabListContextValues_unstable)(state);
+    (0, _useTabListStylesstyles.useTabListStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useTabListStyles_unstable')(state);
+    return (0, _renderTabList.renderTabList_unstable)(state, contextValues);
+});
+TabList.displayName = 'TabList';

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/TabList.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TabList/TabList.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useTabList_unstable } from './useTabList';\nimport { renderTabList_unstable } from './renderTabList';\nimport { useTabListStyles_unstable } from './useTabListStyles.styles';\nimport type { TabListProps } from './TabList.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useTabListContextValues_unstable } from './useTabListContextValues';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * A tab list provides single selection from a set of tabs.\n */\nexport const TabList: ForwardRefComponent<TabListProps> = React.forwardRef((props, ref) => {\n  const state = useTabList_unstable(props, ref);\n  const contextValues = useTabListContextValues_unstable(state);\n\n  useTabListStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useTabListStyles_unstable')(state);\n\n  return renderTabList_unstable(state, contextValues);\n});\n\nTabList.displayName = 'TabList';\n"],"names":["TabList","React","forwardRef","props","ref","state","useTabList_unstable","contextValues","useTabListContextValues_unstable","useTabListStyles_unstable","useCustomStyleHook_unstable","renderTabList_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;4BACa;+BACG;wCACG;yCAGO;qCACL;AAKrC,MAAMA,UAAAA,WAAAA,GAA6CC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACjF,MAAMC,QAAQC,IAAAA,+BAAAA,EAAoBH,OAAOC;IACzC,MAAMG,gBAAgBC,IAAAA,yDAAAA,EAAiCH;IAEvDI,IAAAA,iDAAAA,EAA0BJ;IAE1BK,IAAAA,gDAAAA,EAA4B,6BAA6BL;IAEzD,OAAOM,IAAAA,qCAAAA,EAAuBN,OAAOE;AACvC;AAEAP,QAAQY,WAAW,GAAG"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/TabList.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/TabList.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TabList/TabList.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport { TabValue } from '../Tab/Tab.types';\n\nexport type TabRegisterData = {\n  /**\n   * The value of the tab.\n   */\n  value: TabValue;\n\n  /**\n   * The reference to the tab HTML element.\n   */\n  ref: React.RefObject<HTMLElement>;\n};\n\nexport type RegisterTabEventHandler = (data: TabRegisterData) => void;\n\nexport type SelectTabData = {\n  /**\n   * The value of the selected tab.\n   */\n  value: TabValue;\n};\n\nexport type SelectTabEvent<E = HTMLElement> = React.MouseEvent<E> | React.KeyboardEvent<E> | React.FocusEvent<E>;\n\nexport type SelectTabEventHandler = (event: SelectTabEvent, data: SelectTabData) => void;\n\nexport type TabListSlots = {\n  /**\n   * The slot associated with the root element of this tab list.\n   */\n  root: Slot<'div'>;\n};\n\n/**\n * TabList Props\n */\nexport type TabListProps = ComponentProps<TabListSlots> & {\n  /**\n   * A tab list can supports 'transparent' and 'subtle' appearance.\n   *- 'subtle': Minimizes emphasis to blend into the background until hovered or focused.\n   *- 'transparent': No background and border styling\n   *- 'subtle-circular': Adds background and border styling\n   *- 'filled-circular': Adds background styling\n   *\n   * The appearance affects each of the contained tabs.\n   * @default 'transparent'\n   */\n  appearance?: 'transparent' | 'subtle' | 'subtle-circular' | 'filled-circular';\n\n  /**\n   * Tab size may change between unselected and selected states.\n   * The default scenario is a selected tab has bold text.\n   *\n   * When true, this property requests tabs be the same size whether unselected or selected.\n   * @default true\n   */\n  reserveSelectedTabSpace?: boolean;\n\n  /**\n   * The value of the tab to be selected by default.\n   * Typically useful when the selectedValue is uncontrolled.\n   */\n  defaultSelectedValue?: TabValue;\n\n  /**\n   * A tab list can be set to disable interaction.\n   * @default false\n   */\n  disabled?: boolean;\n\n  /**\n   * Raised when a tab is selected.\n   */\n  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\n  onTabSelect?: SelectTabEventHandler;\n\n  /**\n   * When true, focusing a tab will select it.\n   * @default false\n   */\n  selectTabOnFocus?: boolean;\n\n  /**\n   * The value of the currently selected tab.\n   */\n  selectedValue?: TabValue;\n\n  /**\n   * A tab list can be either 'small', 'medium', or 'large' size.\n   * The size affects each of the contained tabs.\n   * @default 'medium'\n   */\n  size?: 'small' | 'medium' | 'large';\n\n  /**\n   * A tab list can arrange its tabs vertically.\n   * @default false\n   */\n  vertical?: boolean;\n};\n\nexport type TabListContextValue = Pick<\n  TabListProps,\n  'onTabSelect' | 'selectTabOnFocus' | 'selectedValue' | 'reserveSelectedTabSpace'\n> &\n  Required<Pick<TabListProps, 'appearance' | 'disabled' | 'size' | 'vertical'>> & {\n    /** A callback to allow a tab to register itself with the tab list. */\n    onRegister: RegisterTabEventHandler;\n\n    /** A callback to allow a tab to unregister itself with the tab list. */\n    onUnregister: RegisterTabEventHandler;\n    /**\n     * A callback to allow a tab to select itself when pressed.\n     */\n    onSelect: SelectTabEventHandler;\n    /**\n     * Gets the registered tab data along with current and previous selected values.\n     */\n    getRegisteredTabs: () => {\n      selectedValue?: TabValue;\n      previousSelectedValue?: TabValue;\n      registeredTabs: Record<string, TabRegisterData>;\n    };\n  };\n\n/**\n * Context values used in rendering TabList.\n */\nexport type TabListContextValues = {\n  /**\n   * The context of the tab list available to each tab.\n   */\n  tabList: TabListContextValue;\n};\n\n/**\n * State used in rendering TabList.\n */\nexport type TabListState = ComponentState<Required<TabListSlots>> & TabListContextValue;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/TabListContext.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TabListContext: function() {
+        return TabListContext;
+    },
+    TabListProvider: function() {
+        return TabListProvider;
+    },
+    useTabListContext_unstable: function() {
+        return useTabListContext_unstable;
+    }
+});
+const _reactcontextselector = require("@fluentui/react-context-selector");
+const tabListContextDefaultValue = {
+    appearance: 'transparent',
+    reserveSelectedTabSpace: true,
+    selectTabOnFocus: false,
+    disabled: false,
+    selectedValue: undefined,
+    onRegister: ()=>{
+    /* noop */ },
+    onUnregister: ()=>{
+    /* noop */ },
+    onSelect: ()=>{
+    /* noop */ },
+    getRegisteredTabs: ()=>{
+        return {
+            registeredTabs: {}
+        };
+    },
+    size: 'medium',
+    vertical: false
+};
+const TabListContext = (0, _reactcontextselector.createContext)(undefined);
+const TabListProvider = TabListContext.Provider;
+const useTabListContext_unstable = (selector)=>(0, _reactcontextselector.useContextSelector)(TabListContext, (ctx = tabListContextDefaultValue)=>selector(ctx));

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/TabListContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TabList/TabListContext.ts"],"sourcesContent":["import { createContext, useContextSelector } from '@fluentui/react-context-selector';\nimport type { Context, ContextSelector } from '@fluentui/react-context-selector';\nimport { TabListContextValue } from './TabList.types';\n\nconst tabListContextDefaultValue: TabListContextValue = {\n  appearance: 'transparent',\n  reserveSelectedTabSpace: true,\n  selectTabOnFocus: false,\n  disabled: false,\n  selectedValue: undefined,\n  onRegister: () => {\n    /* noop */\n  },\n  onUnregister: () => {\n    /* noop */\n  },\n  onSelect: () => {\n    /* noop */\n  },\n  getRegisteredTabs: () => {\n    return {\n      registeredTabs: {},\n    };\n  },\n  size: 'medium',\n  vertical: false,\n};\n\nexport const TabListContext: Context<TabListContextValue> = createContext<TabListContextValue | undefined>(\n  undefined,\n) as Context<TabListContextValue>;\n\nexport const TabListProvider = TabListContext.Provider;\nexport const useTabListContext_unstable = <T>(selector: ContextSelector<TabListContextValue, T>): T =>\n  useContextSelector(TabListContext, (ctx = tabListContextDefaultValue) => selector(ctx));\n"],"names":["TabListContext","TabListProvider","useTabListContext_unstable","tabListContextDefaultValue","appearance","reserveSelectedTabSpace","selectTabOnFocus","disabled","selectedValue","undefined","onRegister","onUnregister","onSelect","getRegisteredTabs","registeredTabs","size","vertical","createContext","Provider","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA4BaA,cAAAA;eAAAA;;IAIAC,eAAAA;eAAAA;;IACAC,0BAAAA;eAAAA;;;sCAjCqC;AAIlD,MAAMC,6BAAkD;IACtDC,YAAY;IACZC,yBAAyB;IACzBC,kBAAkB;IAClBC,UAAU;IACVC,eAAeC;IACfC,YAAY;IACV,QAAQ,GACV;IACAC,cAAc;IACZ,QAAQ,GACV;IACAC,UAAU;IACR,QAAQ,GACV;IACAC,mBAAmB;QACjB,OAAO;YACLC,gBAAgB,CAAC;QACnB;IACF;IACAC,MAAM;IACNC,UAAU;AACZ;AAEO,MAAMhB,iBAA+CiB,IAAAA,mCAAAA,EAC1DR;AAGK,MAAMR,kBAAkBD,eAAekB,QAAQ;AAC/C,MAAMhB,6BAA6B,CAAIiB,WAC5CC,IAAAA,wCAAAA,EAAmBpB,gBAAgB,CAACqB,MAAMlB,0BAA0B,GAAKgB,SAASE"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TabList: function() {
+        return _TabList.TabList;
+    },
+    TabListContext: function() {
+        return _TabListContext.TabListContext;
+    },
+    TabListProvider: function() {
+        return _TabListContext.TabListProvider;
+    },
+    renderTabList_unstable: function() {
+        return _renderTabList.renderTabList_unstable;
+    },
+    tabListClassNames: function() {
+        return _useTabListStylesstyles.tabListClassNames;
+    },
+    useTabListContextValues_unstable: function() {
+        return _useTabListContextValues.useTabListContextValues_unstable;
+    },
+    useTabListContext_unstable: function() {
+        return _TabListContext.useTabListContext_unstable;
+    },
+    useTabListStyles_unstable: function() {
+        return _useTabListStylesstyles.useTabListStyles_unstable;
+    },
+    useTabList_unstable: function() {
+        return _useTabList.useTabList_unstable;
+    }
+});
+const _TabList = require("./TabList");
+const _TabListContext = require("./TabListContext");
+const _renderTabList = require("./renderTabList");
+const _useTabList = require("./useTabList");
+const _useTabListContextValues = require("./useTabListContextValues");
+const _useTabListStylesstyles = require("./useTabListStyles.styles");

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TabList/index.ts"],"sourcesContent":["export { TabList } from './TabList';\nexport type {\n  RegisterTabEventHandler,\n  SelectTabData,\n  SelectTabEvent,\n  SelectTabEventHandler,\n  TabListContextValue,\n  TabListContextValues,\n  TabListProps,\n  TabListSlots,\n  TabListState,\n  TabRegisterData,\n} from './TabList.types';\nexport { TabListContext, TabListProvider, useTabListContext_unstable } from './TabListContext';\nexport { renderTabList_unstable } from './renderTabList';\nexport { useTabList_unstable } from './useTabList';\nexport { useTabListContextValues_unstable } from './useTabListContextValues';\nexport { tabListClassNames, useTabListStyles_unstable } from './useTabListStyles.styles';\n"],"names":["TabList","TabListContext","TabListProvider","renderTabList_unstable","tabListClassNames","useTabListContextValues_unstable","useTabListContext_unstable","useTabListStyles_unstable","useTabList_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,OAAO;eAAPA,gBAAO;;IAaPC,cAAc;eAAdA,8BAAc;;IAAEC,eAAe;eAAfA,+BAAe;;IAC/BC,sBAAsB;eAAtBA,qCAAsB;;IAGtBC,iBAAiB;eAAjBA,yCAAiB;;IADjBC,gCAAgC;eAAhCA,yDAAgC;;IAHCC,0BAA0B;eAA1BA,0CAA0B;;IAIxCC,yBAAyB;eAAzBA,iDAAyB;;IAF5CC,mBAAmB;eAAnBA,+BAAmB;;;yBAfJ;gCAaoD;+BACrC;4BACH;yCACa;wCACY"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/renderTabList.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderTabList_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderTabList_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _TabListContext = require("./TabListContext");
+const renderTabList_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_TabListContext.TabListProvider, {
+            value: contextValues.tabList,
+            children: state.root.children
+        })
+    });
+};

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/renderTabList.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TabList/renderTabList.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { TabListState, TabListSlots, TabListContextValues } from './TabList.types';\nimport { TabListProvider } from './TabListContext';\n\n/**\n * Render the final JSX of TabList\n */\nexport const renderTabList_unstable = (state: TabListState, contextValues: TabListContextValues) => {\n  assertSlots<TabListSlots>(state);\n\n  return (\n    <state.root>\n      <TabListProvider value={contextValues.tabList}>{state.root.children}</TabListProvider>\n    </state.root>\n  );\n};\n"],"names":["renderTabList_unstable","state","contextValues","assertSlots","_jsx","root","TabListProvider","value","tabList","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAC4B;gCAEI;AAKzB,MAAMA,yBAAyB,CAACC,OAAqBC;IAC1DC,IAAAA,2BAAAA,EAA0BF;IAE1B,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACH,MAAMI,IAAI,EAAA;kBACT,WAAA,GAAAD,IAAAA,eAAA,EAACE,+BAAAA,EAAAA;YAAgBC,OAAOL,cAAcM,OAAO;sBAAGP,MAAMI,IAAI,CAACI,QAAQ;;;AAGzE"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/useTabList.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTabList_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTabList_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reacttabster = require("@fluentui/react-tabster");
+const _reactutilities = require("@fluentui/react-utilities");
+const useTabList_unstable = (props, ref)=>{
+    const { appearance = 'transparent', reserveSelectedTabSpace = true, disabled = false, onTabSelect, selectTabOnFocus = false, size = 'medium', vertical = false } = props;
+    const innerRef = _react.useRef(null);
+    const focusAttributes = (0, _reacttabster.useArrowNavigationGroup)({
+        circular: true,
+        axis: vertical ? 'vertical' : 'horizontal',
+        memorizeCurrent: false,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        unstable_hasDefault: true
+    });
+    const [selectedValue, setSelectedValue] = (0, _reactutilities.useControllableState)({
+        state: props.selectedValue,
+        defaultState: props.defaultSelectedValue,
+        initialState: undefined
+    });
+    // considered usePrevious, but it is sensitive to re-renders
+    // this could cause the previous to move to current in the case where the tab list re-renders.
+    // these refs avoid getRegisteredTabs changing when selectedValue changes and causing
+    // renders for tabs that have not changed.
+    const currentSelectedValue = _react.useRef(undefined);
+    const previousSelectedValue = _react.useRef(undefined);
+    _react.useEffect(()=>{
+        previousSelectedValue.current = currentSelectedValue.current;
+        currentSelectedValue.current = selectedValue;
+    }, [
+        selectedValue
+    ]);
+    const onSelect = (0, _reactutilities.useEventCallback)((event, data)=>{
+        setSelectedValue(data.value);
+        onTabSelect === null || onTabSelect === void 0 ? void 0 : onTabSelect(event, data);
+    });
+    const registeredTabs = _react.useRef({});
+    const onRegister = (0, _reactutilities.useEventCallback)((data)=>{
+        registeredTabs.current[JSON.stringify(data.value)] = data;
+    });
+    const onUnregister = (0, _reactutilities.useEventCallback)((data)=>{
+        delete registeredTabs.current[JSON.stringify(data.value)];
+    });
+    const getRegisteredTabs = _react.useCallback(()=>{
+        return {
+            selectedValue: currentSelectedValue.current,
+            previousSelectedValue: previousSelectedValue.current,
+            registeredTabs: registeredTabs.current
+        };
+    }, []);
+    return {
+        components: {
+            root: 'div'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: (0, _reactutilities.useMergedRefs)(ref, innerRef),
+            role: 'tablist',
+            'aria-orientation': vertical ? 'vertical' : 'horizontal',
+            ...focusAttributes,
+            ...props
+        }), {
+            elementType: 'div'
+        }),
+        appearance,
+        reserveSelectedTabSpace,
+        disabled,
+        selectTabOnFocus,
+        selectedValue,
+        size,
+        vertical,
+        onRegister,
+        onUnregister,
+        onSelect,
+        getRegisteredTabs
+    };
+};

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/useTabListContextValues.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTabListContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTabListContextValues_unstable;
+    }
+});
+function useTabListContextValues_unstable(state) {
+    const { appearance, reserveSelectedTabSpace, disabled, selectTabOnFocus, selectedValue: selectedKey, onRegister, onUnregister, onSelect, getRegisteredTabs, size, vertical } = state;
+    const tabList = {
+        appearance,
+        reserveSelectedTabSpace,
+        disabled,
+        selectTabOnFocus,
+        selectedValue: selectedKey,
+        onSelect,
+        onRegister,
+        onUnregister,
+        getRegisteredTabs,
+        size,
+        vertical
+    };
+    return {
+        tabList
+    };
+}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/useTabListContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TabList/useTabListContextValues.tsx"],"sourcesContent":["import { TabListContextValue, TabListContextValues, TabListState } from './TabList.types';\n\nexport function useTabListContextValues_unstable(state: TabListState): TabListContextValues {\n  const {\n    appearance,\n    reserveSelectedTabSpace,\n    disabled,\n    selectTabOnFocus,\n    selectedValue: selectedKey,\n    onRegister,\n    onUnregister,\n    onSelect,\n    getRegisteredTabs,\n    size,\n    vertical,\n  } = state;\n\n  const tabList: TabListContextValue = {\n    appearance,\n    reserveSelectedTabSpace,\n    disabled,\n    selectTabOnFocus,\n    selectedValue: selectedKey,\n    onSelect,\n    onRegister,\n    onUnregister,\n    getRegisteredTabs,\n    size,\n    vertical,\n  };\n\n  return { tabList };\n}\n"],"names":["useTabListContextValues_unstable","state","appearance","reserveSelectedTabSpace","disabled","selectTabOnFocus","selectedValue","selectedKey","onRegister","onUnregister","onSelect","getRegisteredTabs","size","vertical","tabList"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,iCAAiCC,KAAmB;IAClE,MAAM,EACJC,UAAU,EACVC,uBAAuB,EACvBC,QAAQ,EACRC,gBAAgB,EAChBC,eAAeC,WAAW,EAC1BC,UAAU,EACVC,YAAY,EACZC,QAAQ,EACRC,iBAAiB,EACjBC,IAAI,EACJC,QAAQ,EACT,GAAGZ;IAEJ,MAAMa,UAA+B;QACnCZ;QACAC;QACAC;QACAC;QACAC,eAAeC;QACfG;QACAF;QACAC;QACAE;QACAC;QACAC;IACF;IAEA,OAAO;QAAEC;IAAQ;AACnB"}

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/useTabListStyles.styles.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    tabListClassNames: function() {
+        return tabListClassNames;
+    },
+    useTabListStyles_unstable: function() {
+        return useTabListStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const tabListClassNames = {
+    root: 'fui-TabList'
+};
+/**
+ * Styles for the root slot
+ */ const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    root: {
+        mc9l5x: "f22iagw",
+        Beiy3e4: "f1063pyq",
+        Bnnss6s: "fi64zpg",
+        Eh141a: "flvyvdh",
+        qhf8xq: "f10pi13n"
+    },
+    horizontal: {
+        Bt984gj: "f1q9h2pe",
+        Beiy3e4: "f1063pyq"
+    },
+    vertical: {
+        Bt984gj: "f1q9h2pe",
+        Beiy3e4: "f1vx9l62"
+    },
+    roundedSmall: {
+        i8kkvl: 0,
+        Belr9w4: 0,
+        rmohyg: "f1eyhf9v"
+    },
+    rounded: {
+        i8kkvl: 0,
+        Belr9w4: 0,
+        rmohyg: "faqewft"
+    }
+}, {
+    d: [
+        ".f22iagw{display:flex;}",
+        ".f1063pyq{flex-direction:row;}",
+        ".fi64zpg{flex-shrink:0;}",
+        ".flvyvdh{flex-wrap:nowrap;}",
+        ".f10pi13n{position:relative;}",
+        ".f1q9h2pe{align-items:stretch;}",
+        ".f1vx9l62{flex-direction:column;}",
+        [
+            ".f1eyhf9v{gap:var(--spacingHorizontalSNudge);}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".faqewft{gap:var(--spacingHorizontalS);}",
+            {
+                p: -1
+            }
+        ]
+    ]
+});
+const useTabListStyles_unstable = (state)=>{
+    'use no memo';
+    const { appearance, vertical, size } = state;
+    const styles = useStyles();
+    const isRounded = appearance === 'subtle-circular' || appearance === 'filled-circular';
+    state.root.className = (0, _react.mergeClasses)(tabListClassNames.root, styles.root, vertical ? styles.vertical : styles.horizontal, isRounded && (size === 'small' ? styles.roundedSmall : styles.rounded), state.root.className);
+    return state;
+};

node_modules/@fluentui/react-tabs/lib-commonjs/components/TabList/useTabListStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useTabListStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const tabListClassNames = {\n    root: 'fui-TabList'\n};\n/**\n * Styles for the root slot\n */ const useStyles = makeStyles({\n    root: {\n        display: 'flex',\n        flexDirection: 'row',\n        flexShrink: 0,\n        flexWrap: 'nowrap',\n        position: 'relative'\n    },\n    horizontal: {\n        alignItems: 'stretch',\n        flexDirection: 'row'\n    },\n    vertical: {\n        alignItems: 'stretch',\n        flexDirection: 'column'\n    },\n    roundedSmall: {\n        gap: tokens.spacingHorizontalSNudge\n    },\n    rounded: {\n        gap: tokens.spacingHorizontalS\n    }\n});\n/**\n * Apply styling to the TabList slots based on the state\n */ export const useTabListStyles_unstable = (state)=>{\n    'use no memo';\n    const { appearance, vertical, size } = state;\n    const styles = useStyles();\n    const isRounded = appearance === 'subtle-circular' || appearance === 'filled-circular';\n    state.root.className = mergeClasses(tabListClassNames.root, styles.root, vertical ? styles.vertical : styles.horizontal, isRounded && (size === 'small' ? styles.roundedSmall : styles.rounded), state.root.className);\n    return state;\n};\n"],"names":["tabListClassNames","useTabListStyles_unstable","root","useStyles","__styles","mc9l5x","Beiy3e4","Bnnss6s","Eh141a","qhf8xq","horizontal","Bt984gj","vertical","roundedSmall","i8kkvl","Belr9w4","rmohyg","rounded","d","p","state","appearance","size","styles","isRounded","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,iBAAiB;eAAjBA;;IA8BIC,yBAAyB;eAAzBA;;;uBAhCwB;AAElC,MAAMD,oBAAoB;IAC7BE,MAAM;AACV;AACA;;CAEA,GAAI,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAF,MAAA;QAAAG,QAAA;QAAAC,SAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,QAAA;IAAA;IAAAC,YAAA;QAAAC,SAAA;QAAAL,SAAA;IAAA;IAAAM,UAAA;QAAAD,SAAA;QAAAL,SAAA;IAAA;IAAAO,cAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,QAAA;IAAA;IAAAC,SAAA;QAAAH,QAAA;QAAAC,SAAA;QAAAC,QAAA;IAAA;AAAA,GAAA;IAAAE,GAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;YAAA;YAAA;gBAAAC,GAAA,CAAA;YAAA;SAAA;QAAA;YAAA;YAAA;gBAAAA,GAAA,CAAA;YAAA;SAAA;KAAA;AAAA;AAyBX,MAAMlB,4BAA6BmB,CAAAA;IAC1C;IACA,MAAM,EAAEC,UAAU,EAAET,QAAQ,EAAEU,IAAAA,EAAM,GAAGF;IACvC,MAAMG,SAASpB;IACf,MAAMqB,YAAYH,eAAe,qBAAqBA,eAAe;IACrED,MAAMlB,IAAI,CAACuB,SAAS,GAAGC,IAAAA,mBAAY,EAAC1B,kBAAkBE,IAAI,EAAEqB,OAAOrB,IAAI,EAAEU,WAAWW,OAAOX,QAAQ,GAAGW,OAAOb,UAAU,EAAEc,aAAcF,CAAAA,SAAS,UAAUC,OAAOV,YAAY,GAAGU,OAAON,OAAO,AAAPA,GAAUG,MAAMlB,IAAI,CAACuB,SAAS;IACrN,OAAOL;AACX"}