Initial commit

node_modules/@fluentui/react-accordion/lib-commonjs/Accordion.js

@@ -0,0 +1,31 @@
+"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, {
+    Accordion: function() {
+        return _index.Accordion;
+    },
+    accordionClassNames: function() {
+        return _index.accordionClassNames;
+    },
+    renderAccordion_unstable: function() {
+        return _index.renderAccordion_unstable;
+    },
+    useAccordionContextValues_unstable: function() {
+        return _index.useAccordionContextValues_unstable;
+    },
+    useAccordionStyles_unstable: function() {
+        return _index.useAccordionStyles_unstable;
+    },
+    useAccordion_unstable: function() {
+        return _index.useAccordion_unstable;
+    }
+});
+const _index = require("./components/Accordion/index");

node_modules/@fluentui/react-accordion/lib-commonjs/Accordion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Accordion.ts"],"sourcesContent":["export type {\n  AccordionContextValues,\n  AccordionIndex,\n  AccordionProps,\n  AccordionSlots,\n  AccordionState,\n  AccordionToggleData,\n  AccordionToggleEvent,\n  AccordionToggleEventHandler,\n} from './components/Accordion/index';\nexport {\n  Accordion,\n  accordionClassNames,\n  renderAccordion_unstable,\n  useAccordionContextValues_unstable,\n  useAccordionStyles_unstable,\n  useAccordion_unstable,\n} from './components/Accordion/index';\n"],"names":["Accordion","accordionClassNames","renderAccordion_unstable","useAccordionContextValues_unstable","useAccordionStyles_unstable","useAccordion_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAWEA,SAAS;eAATA,gBAAS;;IACTC,mBAAmB;eAAnBA,0BAAmB;;IACnBC,wBAAwB;eAAxBA,+BAAwB;;IACxBC,kCAAkC;eAAlCA,yCAAkC;;IAClCC,2BAA2B;eAA3BA,kCAA2B;;IAC3BC,qBAAqB;eAArBA,4BAAqB;;;uBAChB"}

node_modules/@fluentui/react-accordion/lib-commonjs/AccordionHeader.js

@@ -0,0 +1,31 @@
+"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, {
+    AccordionHeader: function() {
+        return _index.AccordionHeader;
+    },
+    accordionHeaderClassNames: function() {
+        return _index.accordionHeaderClassNames;
+    },
+    renderAccordionHeader_unstable: function() {
+        return _index.renderAccordionHeader_unstable;
+    },
+    useAccordionHeaderContextValues_unstable: function() {
+        return _index.useAccordionHeaderContextValues_unstable;
+    },
+    useAccordionHeaderStyles_unstable: function() {
+        return _index.useAccordionHeaderStyles_unstable;
+    },
+    useAccordionHeader_unstable: function() {
+        return _index.useAccordionHeader_unstable;
+    }
+});
+const _index = require("./components/AccordionHeader/index");

node_modules/@fluentui/react-accordion/lib-commonjs/AccordionHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AccordionHeader.ts"],"sourcesContent":["export type {\n  AccordionHeaderContextValues,\n  AccordionHeaderExpandIconPosition,\n  AccordionHeaderProps,\n  AccordionHeaderSize,\n  AccordionHeaderSlots,\n  AccordionHeaderState,\n} from './components/AccordionHeader/index';\nexport {\n  AccordionHeader,\n  accordionHeaderClassNames,\n  renderAccordionHeader_unstable,\n  useAccordionHeaderContextValues_unstable,\n  useAccordionHeaderStyles_unstable,\n  useAccordionHeader_unstable,\n} from './components/AccordionHeader/index';\n"],"names":["AccordionHeader","accordionHeaderClassNames","renderAccordionHeader_unstable","useAccordionHeaderContextValues_unstable","useAccordionHeaderStyles_unstable","useAccordionHeader_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IASEA,eAAe;eAAfA,sBAAe;;IACfC,yBAAyB;eAAzBA,gCAAyB;;IACzBC,8BAA8B;eAA9BA,qCAA8B;;IAC9BC,wCAAwC;eAAxCA,+CAAwC;;IACxCC,iCAAiC;eAAjCA,wCAAiC;;IACjCC,2BAA2B;eAA3BA,kCAA2B;;;uBACtB"}

node_modules/@fluentui/react-accordion/lib-commonjs/AccordionItem.js

@@ -0,0 +1,31 @@
+"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, {
+    AccordionItem: function() {
+        return _index.AccordionItem;
+    },
+    accordionItemClassNames: function() {
+        return _index.accordionItemClassNames;
+    },
+    renderAccordionItem_unstable: function() {
+        return _index.renderAccordionItem_unstable;
+    },
+    useAccordionItemContextValues_unstable: function() {
+        return _index.useAccordionItemContextValues_unstable;
+    },
+    useAccordionItemStyles_unstable: function() {
+        return _index.useAccordionItemStyles_unstable;
+    },
+    useAccordionItem_unstable: function() {
+        return _index.useAccordionItem_unstable;
+    }
+});
+const _index = require("./components/AccordionItem/index");

node_modules/@fluentui/react-accordion/lib-commonjs/AccordionItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AccordionItem.ts"],"sourcesContent":["export type {\n  AccordionItemContextValues,\n  AccordionItemProps,\n  AccordionItemSlots,\n  AccordionItemState,\n  AccordionItemValue,\n} from './components/AccordionItem/index';\nexport {\n  AccordionItem,\n  accordionItemClassNames,\n  renderAccordionItem_unstable,\n  useAccordionItemContextValues_unstable,\n  useAccordionItemStyles_unstable,\n  useAccordionItem_unstable,\n} from './components/AccordionItem/index';\n"],"names":["AccordionItem","accordionItemClassNames","renderAccordionItem_unstable","useAccordionItemContextValues_unstable","useAccordionItemStyles_unstable","useAccordionItem_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAQEA,aAAa;eAAbA,oBAAa;;IACbC,uBAAuB;eAAvBA,8BAAuB;;IACvBC,4BAA4B;eAA5BA,mCAA4B;;IAC5BC,sCAAsC;eAAtCA,6CAAsC;;IACtCC,+BAA+B;eAA/BA,sCAA+B;;IAC/BC,yBAAyB;eAAzBA,gCAAyB;;;uBACpB"}

node_modules/@fluentui/react-accordion/lib-commonjs/AccordionPanel.js

@@ -0,0 +1,28 @@
+"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, {
+    AccordionPanel: function() {
+        return _index.AccordionPanel;
+    },
+    accordionPanelClassNames: function() {
+        return _index.accordionPanelClassNames;
+    },
+    renderAccordionPanel_unstable: function() {
+        return _index.renderAccordionPanel_unstable;
+    },
+    useAccordionPanelStyles_unstable: function() {
+        return _index.useAccordionPanelStyles_unstable;
+    },
+    useAccordionPanel_unstable: function() {
+        return _index.useAccordionPanel_unstable;
+    }
+});
+const _index = require("./components/AccordionPanel/index");

node_modules/@fluentui/react-accordion/lib-commonjs/AccordionPanel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AccordionPanel.ts"],"sourcesContent":["export type { AccordionPanelProps, AccordionPanelSlots, AccordionPanelState } from './components/AccordionPanel/index';\nexport {\n  AccordionPanel,\n  accordionPanelClassNames,\n  renderAccordionPanel_unstable,\n  useAccordionPanelStyles_unstable,\n  useAccordionPanel_unstable,\n} from './components/AccordionPanel/index';\n"],"names":["AccordionPanel","accordionPanelClassNames","renderAccordionPanel_unstable","useAccordionPanelStyles_unstable","useAccordionPanel_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEEA,cAAc;eAAdA,qBAAc;;IACdC,wBAAwB;eAAxBA,+BAAwB;;IACxBC,6BAA6B;eAA7BA,oCAA6B;;IAC7BC,gCAAgC;eAAhCA,uCAAgC;;IAChCC,0BAA0B;eAA1BA,iCAA0B;;;uBACrB"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/Accordion.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Accordion", {
+    enumerable: true,
+    get: function() {
+        return Accordion;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _renderAccordion = require("./renderAccordion");
+const _useAccordion = require("./useAccordion");
+const _useAccordionContextValues = require("./useAccordionContextValues");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _useAccordionStylesstyles = require("./useAccordionStyles.styles");
+const Accordion = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useAccordion.useAccordion_unstable)(props, ref);
+    const contextValues = (0, _useAccordionContextValues.useAccordionContextValues_unstable)(state);
+    (0, _useAccordionStylesstyles.useAccordionStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useAccordionStyles_unstable')(state);
+    return (0, _renderAccordion.renderAccordion_unstable)(state, contextValues);
+});
+Accordion.displayName = 'Accordion';

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/Accordion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Accordion/Accordion.tsx"],"sourcesContent":["import * as React from 'react';\nimport { renderAccordion_unstable } from './renderAccordion';\nimport { useAccordion_unstable } from './useAccordion';\nimport { useAccordionContextValues_unstable } from './useAccordionContextValues';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\nimport { useAccordionStyles_unstable } from './useAccordionStyles.styles';\nimport type { AccordionProps } from './Accordion.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\n\n/**\n * Define a styled Accordion, using the `useAccordion_unstable` and `useAccordionStyles_unstable` hooks.\n */\nexport const Accordion: ForwardRefComponent<AccordionProps> & (<TItem>(props: AccordionProps<TItem>) => JSX.Element) =\n  React.forwardRef<HTMLDivElement, AccordionProps>((props, ref) => {\n    const state = useAccordion_unstable(props, ref);\n    const contextValues = useAccordionContextValues_unstable(state);\n\n    useAccordionStyles_unstable(state);\n\n    useCustomStyleHook_unstable('useAccordionStyles_unstable')(state);\n\n    return renderAccordion_unstable(state, contextValues);\n  }) as ForwardRefComponent<AccordionProps> & (<TItem>(props: AccordionProps<TItem>) => JSX.Element);\n\nAccordion.displayName = 'Accordion';\n"],"names":["Accordion","React","forwardRef","props","ref","state","useAccordion_unstable","contextValues","useAccordionContextValues_unstable","useAccordionStyles_unstable","useCustomStyleHook_unstable","renderAccordion_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;iCACkB;8BACH;2CACa;qCACP;0CACA;AAOrC,MAAMA,YAAAA,WAAAA,GACXC,OAAMC,UAAU,CAAiC,CAACC,OAAOC;IACvD,MAAMC,QAAQC,IAAAA,mCAAAA,EAAsBH,OAAOC;IAC3C,MAAMG,gBAAgBC,IAAAA,6DAAAA,EAAmCH;IAEzDI,IAAAA,qDAAAA,EAA4BJ;IAE5BK,IAAAA,gDAAAA,EAA4B,+BAA+BL;IAE3D,OAAOM,IAAAA,yCAAAA,EAAyBN,OAAOE;AACzC;AAEFP,UAAUY,WAAW,GAAG"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/Accordion.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-accordion/lib-commonjs/components/Accordion/Accordion.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Accordion/Accordion.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport { AccordionContextValue } from '../../contexts/accordion';\nimport type { AccordionItemValue } from '../AccordionItem/AccordionItem.types';\n\nexport type AccordionIndex = number | number[];\n\nexport type AccordionToggleEvent<E = HTMLElement> = React.MouseEvent<E> | React.KeyboardEvent<E>;\n\nexport type AccordionToggleEventHandler<Value = AccordionItemValue> = (\n  event: AccordionToggleEvent,\n  data: AccordionToggleData<Value>,\n) => void;\n\nexport type AccordionContextValues = {\n  accordion: AccordionContextValue;\n};\n\nexport type AccordionSlots = {\n  root: NonNullable<Slot<'div'>>;\n};\n\nexport type AccordionToggleData<Value = AccordionItemValue> = {\n  value: Value;\n  openItems: Value[];\n};\n\nexport type AccordionProps<Value = AccordionItemValue> = ComponentProps<AccordionSlots> & {\n  /**\n   * Default value for the uncontrolled state of the panel.\n   */\n  defaultOpenItems?: Value | Value[];\n\n  /**\n   * Indicates if Accordion support multiple Panels closed at the same time.\n   */\n  collapsible?: boolean;\n\n  /**\n   * Indicates if Accordion support multiple Panels opened at the same time.\n   */\n  multiple?: boolean;\n\n  /**\n   * @deprecated Arrow keyboard navigation is not recommended for accordions. Consider using Tree if arrow navigation is a hard requirement.\n   * Indicates if keyboard navigation is available and gives two options, linear or circular navigation.\n   */\n  navigation?: 'linear' | 'circular';\n\n  /**\n   * Callback to be called when the opened items change.\n   */\n  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\n  onToggle?: AccordionToggleEventHandler<Value>;\n\n  /**\n   * Controls the state of the panel.\n   */\n  openItems?: Value | Value[];\n};\n\nexport type AccordionState<Value = AccordionItemValue> = ComponentState<AccordionSlots> & AccordionContextValue<Value>;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/index.js

@@ -0,0 +1,35 @@
+"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, {
+    Accordion: function() {
+        return _Accordion.Accordion;
+    },
+    accordionClassNames: function() {
+        return _useAccordionStylesstyles.accordionClassNames;
+    },
+    renderAccordion_unstable: function() {
+        return _renderAccordion.renderAccordion_unstable;
+    },
+    useAccordionContextValues_unstable: function() {
+        return _useAccordionContextValues.useAccordionContextValues_unstable;
+    },
+    useAccordionStyles_unstable: function() {
+        return _useAccordionStylesstyles.useAccordionStyles_unstable;
+    },
+    useAccordion_unstable: function() {
+        return _useAccordion.useAccordion_unstable;
+    }
+});
+const _Accordion = require("./Accordion");
+const _renderAccordion = require("./renderAccordion");
+const _useAccordion = require("./useAccordion");
+const _useAccordionStylesstyles = require("./useAccordionStyles.styles");
+const _useAccordionContextValues = require("./useAccordionContextValues");

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Accordion/index.ts"],"sourcesContent":["export { Accordion } from './Accordion';\nexport type {\n  AccordionContextValues,\n  AccordionIndex,\n  AccordionProps,\n  AccordionSlots,\n  AccordionState,\n  AccordionToggleData,\n  AccordionToggleEvent,\n  AccordionToggleEventHandler,\n} from './Accordion.types';\nexport { renderAccordion_unstable } from './renderAccordion';\nexport { useAccordion_unstable } from './useAccordion';\nexport { accordionClassNames, useAccordionStyles_unstable } from './useAccordionStyles.styles';\nexport { useAccordionContextValues_unstable } from './useAccordionContextValues';\n"],"names":["Accordion","accordionClassNames","renderAccordion_unstable","useAccordionContextValues_unstable","useAccordionStyles_unstable","useAccordion_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,SAAS;eAATA,oBAAS;;IAaTC,mBAAmB;eAAnBA,6CAAmB;;IAFnBC,wBAAwB;eAAxBA,yCAAwB;;IAGxBC,kCAAkC;eAAlCA,6DAAkC;;IADbC,2BAA2B;eAA3BA,qDAA2B;;IADhDC,qBAAqB;eAArBA,mCAAqB;;;2BAZJ;iCAWe;8BACH;0CAC2B;2CACd"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/renderAccordion.js

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

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/renderAccordion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Accordion/renderAccordion.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport { assertSlots } from '@fluentui/react-utilities';\n\nimport type { AccordionState, AccordionSlots, AccordionContextValues } from './Accordion.types';\nimport { AccordionProvider } from '../../contexts/accordion';\n\n/**\n * Function that renders the final JSX of the component\n */\nexport const renderAccordion_unstable = (state: AccordionState, contextValues: AccordionContextValues) => {\n  assertSlots<AccordionSlots>(state);\n\n  return (\n    <state.root>\n      <AccordionProvider value={contextValues.accordion}>{state.root.children}</AccordionProvider>\n    </state.root>\n  );\n};\n"],"names":["renderAccordion_unstable","state","contextValues","assertSlots","_jsx","root","AccordionProvider","value","accordion","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;4BAVb;gCAE4B;2BAGM;AAK3B,MAAMA,2BAA2B,CAACC,OAAuBC;IAC9DC,IAAAA,2BAAAA,EAA4BF;IAE5B,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACH,MAAMI,IAAI,EAAA;kBACT,WAAA,GAAAD,IAAAA,eAAA,EAACE,4BAAAA,EAAAA;YAAkBC,OAAOL,cAAcM,SAAS;sBAAGP,MAAMI,IAAI,CAACI,QAAQ;;;AAG7E"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/useAccordion.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordion_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordion_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reacttabster = require("@fluentui/react-tabster");
+const useAccordion_unstable = (props, ref)=>{
+    const { openItems: controlledOpenItems, defaultOpenItems, multiple = false, collapsible = false, onToggle, navigation } = props;
+    const [openItems, setOpenItems] = (0, _reactutilities.useControllableState)({
+        state: _react.useMemo(()=>normalizeValues(controlledOpenItems), [
+            controlledOpenItems
+        ]),
+        defaultState: defaultOpenItems && (()=>initializeUncontrolledOpenItems({
+                defaultOpenItems,
+                multiple
+            })),
+        initialState: []
+    });
+    /** FIXME: deprecated will be removed after navigation prop is removed */ const arrowNavigationProps = (0, _reacttabster.useArrowNavigationGroup)({
+        circular: navigation === 'circular',
+        tabbable: true
+    });
+    const requestToggle = (0, _reactutilities.useEventCallback)((data)=>{
+        const nextOpenItems = updateOpenItems(data.value, openItems, multiple, collapsible);
+        onToggle === null || onToggle === void 0 ? void 0 : onToggle(data.event, {
+            value: data.value,
+            openItems: nextOpenItems
+        });
+        setOpenItems(nextOpenItems);
+    });
+    return {
+        collapsible,
+        multiple,
+        navigation,
+        openItems,
+        requestToggle,
+        components: {
+            root: 'div'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            ...props,
+            ...navigation ? arrowNavigationProps : undefined,
+            // 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: ref
+        }), {
+            elementType: 'div'
+        })
+    };
+};
+/**
+ * Initial value for the uncontrolled case of the list of open indexes
+ */ function initializeUncontrolledOpenItems({ defaultOpenItems, multiple }) {
+    if (defaultOpenItems !== undefined) {
+        if (Array.isArray(defaultOpenItems)) {
+            return multiple ? defaultOpenItems : [
+                defaultOpenItems[0]
+            ];
+        }
+        return [
+            defaultOpenItems
+        ];
+    }
+    return [];
+}
+/**
+ * Updates the list of open indexes based on an index that changes
+ * @param value - the index that will change
+ * @param previousOpenItems - list of current open indexes
+ * @param multiple - if Accordion support multiple Panels opened at the same time
+ * @param collapsible - if Accordion support multiple Panels closed at the same time
+ */ function updateOpenItems(value, previousOpenItems, multiple, collapsible) {
+    if (multiple) {
+        if (previousOpenItems.includes(value)) {
+            if (previousOpenItems.length > 1 || collapsible) {
+                return previousOpenItems.filter((i)=>i !== value);
+            }
+        } else {
+            return [
+                ...previousOpenItems,
+                value
+            ].sort();
+        }
+    } else {
+        return previousOpenItems[0] === value && collapsible ? [] : [
+            value
+        ];
+    }
+    return previousOpenItems;
+}
+/**
+ * Normalizes Accordion index into an array of indexes
+ */ function normalizeValues(index) {
+    if (index === undefined) {
+        return undefined;
+    }
+    return Array.isArray(index) ? index : [
+        index
+    ];
+}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/useAccordionContextValues.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordionContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordionContextValues_unstable;
+    }
+});
+function useAccordionContextValues_unstable(state) {
+    const { navigation, openItems, requestToggle, multiple, collapsible } = state;
+    // This context is created with "@fluentui/react-context-selector", these is no sense to memoize it
+    const accordion = {
+        navigation,
+        openItems,
+        requestToggle,
+        collapsible,
+        multiple
+    };
+    return {
+        accordion
+    };
+}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/useAccordionContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Accordion/useAccordionContextValues.ts"],"sourcesContent":["import type { AccordionContextValue } from '../../contexts/accordion';\nimport type { AccordionContextValues, AccordionState } from './Accordion.types';\n\nexport function useAccordionContextValues_unstable(state: AccordionState): AccordionContextValues {\n  const { navigation, openItems, requestToggle, multiple, collapsible } = state;\n\n  // This context is created with \"@fluentui/react-context-selector\", these is no sense to memoize it\n  const accordion: AccordionContextValue = {\n    navigation,\n    openItems,\n    requestToggle,\n    collapsible,\n    multiple,\n  };\n\n  return { accordion };\n}\n"],"names":["useAccordionContextValues_unstable","state","navigation","openItems","requestToggle","multiple","collapsible","accordion"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;AAAT,SAASA,mCAAmCC,KAAqB;IACtE,MAAM,EAAEC,UAAU,EAAEC,SAAS,EAAEC,aAAa,EAAEC,QAAQ,EAAEC,WAAW,EAAE,GAAGL;IAExE,mGAAmG;IACnG,MAAMM,YAAmC;QACvCL;QACAC;QACAC;QACAE;QACAD;IACF;IAEA,OAAO;QAAEE;IAAU;AACrB"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/useAccordionStyles.styles.js

@@ -0,0 +1,27 @@
+"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, {
+    accordionClassNames: function() {
+        return accordionClassNames;
+    },
+    useAccordionStyles_unstable: function() {
+        return useAccordionStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const accordionClassNames = {
+    root: 'fui-Accordion'
+};
+const useAccordionStyles_unstable = (state)=>{
+    'use no memo';
+    state.root.className = (0, _react.mergeClasses)(accordionClassNames.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/Accordion/useAccordionStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useAccordionStyles.styles.js"],"sourcesContent":["import { mergeClasses } from '@griffel/react';\nexport const accordionClassNames = {\n    root: 'fui-Accordion'\n};\nexport const useAccordionStyles_unstable = (state)=>{\n    'use no memo';\n    state.root.className = mergeClasses(accordionClassNames.root, state.root.className);\n    return state;\n};\n"],"names":["accordionClassNames","useAccordionStyles_unstable","root","state","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACaA,mBAAmB;eAAnBA;;IAGAC,2BAA2B;eAA3BA;;;uBAJgB;AACtB,MAAMD,sBAAsB;IAC/BE,MAAM;AACV;AACO,MAAMD,8BAA+BE,CAAAA;IACxC;IACAA,MAAMD,IAAI,CAACE,SAAS,GAAGC,IAAAA,mBAAY,EAACL,oBAAoBE,IAAI,EAAEC,MAAMD,IAAI,CAACE,SAAS;IAClF,OAAOD;AACX"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/AccordionHeader.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AccordionHeader", {
+    enumerable: true,
+    get: function() {
+        return AccordionHeader;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useAccordionHeader = require("./useAccordionHeader");
+const _renderAccordionHeader = require("./renderAccordionHeader");
+const _useAccordionHeaderStylesstyles = require("./useAccordionHeaderStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _useAccordionHeaderContextValues = require("./useAccordionHeaderContextValues");
+const AccordionHeader = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useAccordionHeader.useAccordionHeader_unstable)(props, ref);
+    const contextValues = (0, _useAccordionHeaderContextValues.useAccordionHeaderContextValues_unstable)(state);
+    (0, _useAccordionHeaderStylesstyles.useAccordionHeaderStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useAccordionHeaderStyles_unstable')(state);
+    return (0, _renderAccordionHeader.renderAccordionHeader_unstable)(state, contextValues);
+});
+AccordionHeader.displayName = 'AccordionHeader';

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/AccordionHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionHeader/AccordionHeader.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useAccordionHeader_unstable } from './useAccordionHeader';\nimport { renderAccordionHeader_unstable } from './renderAccordionHeader';\nimport { useAccordionHeaderStyles_unstable } from './useAccordionHeaderStyles.styles';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\nimport { useAccordionHeaderContextValues_unstable } from './useAccordionHeaderContextValues';\nimport type { AccordionHeaderProps } from './AccordionHeader.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\n\n/**\n * Define a styled AccordionHeader, using the `useAccordionHeader_unstable` and `useAccordionHeaderStyles_unstable`\n * hooks.\n */\nexport const AccordionHeader: ForwardRefComponent<AccordionHeaderProps> = React.forwardRef((props, ref) => {\n  const state = useAccordionHeader_unstable(props, ref);\n  const contextValues = useAccordionHeaderContextValues_unstable(state);\n\n  useAccordionHeaderStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useAccordionHeaderStyles_unstable')(state);\n\n  return renderAccordionHeader_unstable(state, contextValues);\n});\n\nAccordionHeader.displayName = 'AccordionHeader';\n"],"names":["AccordionHeader","React","forwardRef","props","ref","state","useAccordionHeader_unstable","contextValues","useAccordionHeaderContextValues_unstable","useAccordionHeaderStyles_unstable","useCustomStyleHook_unstable","renderAccordionHeader_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAaaA;;;eAAAA;;;;iEAbU;oCACqB;uCACG;gDACG;qCACN;iDACa;AAQlD,MAAMA,kBAAAA,WAAAA,GAA6DC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACjG,MAAMC,QAAQC,IAAAA,+CAAAA,EAA4BH,OAAOC;IACjD,MAAMG,gBAAgBC,IAAAA,yEAAAA,EAAyCH;IAE/DI,IAAAA,iEAAAA,EAAkCJ;IAElCK,IAAAA,gDAAAA,EAA4B,qCAAqCL;IAEjE,OAAOM,IAAAA,qDAAAA,EAA+BN,OAAOE;AAC/C;AAEAP,gBAAgBY,WAAW,GAAG"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/AccordionHeader.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/AccordionHeader.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionHeader/AccordionHeader.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type { ARIAButtonSlotProps } from '@fluentui/react-aria';\nimport type { AccordionHeaderContextValue } from '../../contexts/accordionHeader';\n\nexport type AccordionHeaderSize = 'small' | 'medium' | 'large' | 'extra-large';\nexport type AccordionHeaderExpandIconPosition = 'start' | 'end';\n\nexport type AccordionHeaderContextValues = {\n  accordionHeader: AccordionHeaderContextValue;\n};\n\nexport type AccordionHeaderSlots = {\n  /**\n   * The element wrapping the button. By default this is a div, but can be a heading.\n   */\n  root: NonNullable<Slot<'div', 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'>>;\n  /**\n   * The component to be used as button in heading\n   */\n  button: NonNullable<Slot<ARIAButtonSlotProps<'a'>>>;\n  /**\n   * Expand icon slot rendered before (or after) children content in heading.\n   */\n  expandIcon?: Slot<'span'>;\n  /**\n   * Expand icon slot rendered before (or after) children content in heading.\n   */\n  icon?: Slot<'div'>;\n};\n\nexport type AccordionHeaderProps = ComponentProps<Partial<AccordionHeaderSlots>> & {\n  /**\n   * The position of the expand  icon slot in heading.\n   */\n  expandIconPosition?: AccordionHeaderExpandIconPosition;\n\n  /**\n   * Indicates if the AccordionHeader should be rendered inline.\n   */\n  inline?: boolean;\n\n  /**\n   * Size of spacing in the heading.\n   */\n  size?: AccordionHeaderSize;\n};\n\nexport type AccordionHeaderState = ComponentState<AccordionHeaderSlots> &\n  Required<Pick<AccordionHeaderProps, 'inline'>> &\n  AccordionHeaderContextValue;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/index.js

@@ -0,0 +1,35 @@
+"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, {
+    AccordionHeader: function() {
+        return _AccordionHeader.AccordionHeader;
+    },
+    accordionHeaderClassNames: function() {
+        return _useAccordionHeaderStylesstyles.accordionHeaderClassNames;
+    },
+    renderAccordionHeader_unstable: function() {
+        return _renderAccordionHeader.renderAccordionHeader_unstable;
+    },
+    useAccordionHeaderContextValues_unstable: function() {
+        return _useAccordionHeaderContextValues.useAccordionHeaderContextValues_unstable;
+    },
+    useAccordionHeaderStyles_unstable: function() {
+        return _useAccordionHeaderStylesstyles.useAccordionHeaderStyles_unstable;
+    },
+    useAccordionHeader_unstable: function() {
+        return _useAccordionHeader.useAccordionHeader_unstable;
+    }
+});
+const _AccordionHeader = require("./AccordionHeader");
+const _renderAccordionHeader = require("./renderAccordionHeader");
+const _useAccordionHeader = require("./useAccordionHeader");
+const _useAccordionHeaderContextValues = require("./useAccordionHeaderContextValues");
+const _useAccordionHeaderStylesstyles = require("./useAccordionHeaderStyles.styles");

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionHeader/index.ts"],"sourcesContent":["export { AccordionHeader } from './AccordionHeader';\nexport type {\n  AccordionHeaderContextValues,\n  AccordionHeaderExpandIconPosition,\n  AccordionHeaderProps,\n  AccordionHeaderSize,\n  AccordionHeaderSlots,\n  AccordionHeaderState,\n} from './AccordionHeader.types';\nexport { renderAccordionHeader_unstable } from './renderAccordionHeader';\nexport { useAccordionHeader_unstable } from './useAccordionHeader';\nexport { useAccordionHeaderContextValues_unstable } from './useAccordionHeaderContextValues';\nexport { accordionHeaderClassNames, useAccordionHeaderStyles_unstable } from './useAccordionHeaderStyles.styles';\n"],"names":["AccordionHeader","accordionHeaderClassNames","renderAccordionHeader_unstable","useAccordionHeaderContextValues_unstable","useAccordionHeaderStyles_unstable","useAccordionHeader_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,eAAe;eAAfA,gCAAe;;IAYfC,yBAAyB;eAAzBA,yDAAyB;;IAHzBC,8BAA8B;eAA9BA,qDAA8B;;IAE9BC,wCAAwC;eAAxCA,yEAAwC;;IACbC,iCAAiC;eAAjCA,iEAAiC;;IAF5DC,2BAA2B;eAA3BA,+CAA2B;;;iCAVJ;uCASe;oCACH;iDACa;gDACoB"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/renderAccordionHeader.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderAccordionHeader_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderAccordionHeader_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _accordionHeader = require("../../contexts/accordionHeader");
+const renderAccordionHeader_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_accordionHeader.AccordionHeaderProvider, {
+        value: contextValues.accordionHeader,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {
+            children: /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.button, {
+                children: [
+                    state.expandIconPosition === 'start' && state.expandIcon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.expandIcon, {}),
+                    state.icon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.icon, {}),
+                    state.root.children,
+                    state.expandIconPosition === 'end' && state.expandIcon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.expandIcon, {})
+                ]
+            })
+        })
+    });
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/renderAccordionHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionHeader/renderAccordionHeader.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { AccordionHeaderState, AccordionHeaderSlots, AccordionHeaderContextValues } from './AccordionHeader.types';\nimport { AccordionHeaderProvider } from '../../contexts/accordionHeader';\n\n/**\n * Function that renders the final JSX of the component\n */\nexport const renderAccordionHeader_unstable = (\n  state: AccordionHeaderState,\n  contextValues: AccordionHeaderContextValues,\n) => {\n  assertSlots<AccordionHeaderSlots>(state);\n\n  return (\n    <AccordionHeaderProvider value={contextValues.accordionHeader}>\n      <state.root>\n        <state.button>\n          {state.expandIconPosition === 'start' && state.expandIcon && <state.expandIcon />}\n          {state.icon && <state.icon />}\n          {state.root.children}\n          {state.expandIconPosition === 'end' && state.expandIcon && <state.expandIcon />}\n        </state.button>\n      </state.root>\n    </AccordionHeaderProvider>\n  );\n};\n"],"names":["renderAccordionHeader_unstable","state","contextValues","assertSlots","_jsx","AccordionHeaderProvider","value","accordionHeader","root","_jsxs","button","expandIconPosition","expandIcon","icon","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;4BATb;gCAE4B;iCAEY;AAKjC,MAAMA,iCAAiC,CAC5CC,OACAC;IAEAC,IAAAA,2BAAAA,EAAkCF;IAElC,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACC,wCAAAA,EAAAA;QAAwBC,OAAOJ,cAAcK,eAAe;kBAC3D,WAAA,GAAAH,IAAAA,eAAA,EAACH,MAAMO,IAAI,EAAA;sBACT,WAAA,GAAAC,IAAAA,gBAAA,EAACR,MAAMS,MAAM,EAAA;;oBACVT,MAAMU,kBAAkB,KAAK,WAAWV,MAAMW,UAAU,IAAA,WAAA,GAAIR,IAAAA,eAAA,EAACH,MAAMW,UAAU,EAAA,CAAA;oBAC7EX,MAAMY,IAAI,IAAA,WAAA,GAAIT,IAAAA,eAAA,EAACH,MAAMY,IAAI,EAAA,CAAA;oBACzBZ,MAAMO,IAAI,CAACM,QAAQ;oBACnBb,MAAMU,kBAAkB,KAAK,SAASV,MAAMW,UAAU,IAAA,WAAA,GAAIR,IAAAA,eAAA,EAACH,MAAMW,UAAU,EAAA,CAAA;;;;;AAKtF"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/useAccordionHeader.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordionHeader_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordionHeader_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactaria = require("@fluentui/react-aria");
+const _accordion = require("../../contexts/accordion");
+const _reacticons = require("@fluentui/react-icons");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _accordionItem = require("../../contexts/accordionItem");
+const _reactmotion = require("@fluentui/react-motion");
+const useAccordionHeader_unstable = (props, ref)=>{
+    const { icon, button, expandIcon, inline = false, size = 'medium', expandIconPosition = 'start' } = props;
+    const { value, disabled, open } = (0, _accordionItem.useAccordionItemContext_unstable)();
+    const requestToggle = (0, _accordion.useAccordionContext_unstable)((ctx)=>ctx.requestToggle);
+    /**
+   * force disabled state on button if accordion isn't collapsible
+   * and this is the only item opened
+   */ const disabledFocusable = (0, _accordion.useAccordionContext_unstable)((ctx)=>!ctx.collapsible && ctx.openItems.length === 1 && open);
+    const { dir } = (0, _reactsharedcontexts.useFluent_unstable)();
+    // Calculate how to rotate the expand icon [>] (ChevronRightRegular)
+    let expandIconRotation;
+    if (expandIconPosition === 'end') {
+        // If expand icon is at the end, the chevron points up [^] when open, and down [v] when closed
+        expandIconRotation = open ? -90 : 90;
+    } else {
+        // Otherwise, the chevron points down [v] when open, and right [>] (or left [<] in RTL) when closed
+        expandIconRotation = open ? 90 : dir !== 'rtl' ? 0 : 180;
+    }
+    const buttonSlot = _reactutilities.slot.always(button, {
+        elementType: 'button',
+        defaultProps: {
+            disabled,
+            disabledFocusable,
+            'aria-expanded': open,
+            type: 'button'
+        }
+    });
+    buttonSlot.onClick = (0, _reactutilities.useEventCallback)((event)=>{
+        if ((0, _reactutilities.isResolvedShorthand)(button)) {
+            var _button_onClick;
+            (_button_onClick = button.onClick) === null || _button_onClick === void 0 ? void 0 : _button_onClick.call(button, event);
+        }
+        if (!event.defaultPrevented) {
+            requestToggle({
+                value,
+                event
+            });
+        }
+    });
+    return {
+        disabled,
+        open,
+        size,
+        inline,
+        expandIconPosition,
+        components: {
+            root: 'div',
+            button: 'button',
+            expandIcon: 'span',
+            icon: '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: ref,
+            ...props
+        }), {
+            elementType: 'div'
+        }),
+        icon: _reactutilities.slot.optional(icon, {
+            elementType: 'div'
+        }),
+        expandIcon: _reactutilities.slot.optional(expandIcon, {
+            renderByDefault: true,
+            defaultProps: {
+                children: /*#__PURE__*/ _react.createElement(_reacticons.ChevronRightRegular, {
+                    style: {
+                        transform: `rotate(${expandIconRotation}deg)`,
+                        transition: `transform ${_reactmotion.motionTokens.durationNormal}ms ease-out`
+                    }
+                }),
+                'aria-hidden': true
+            },
+            elementType: 'span'
+        }),
+        button: (0, _reactaria.useARIAButtonProps)(buttonSlot.as, buttonSlot)
+    };
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/useAccordionHeaderContextValues.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordionHeaderContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordionHeaderContextValues_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+function useAccordionHeaderContextValues_unstable(state) {
+    const { disabled, expandIconPosition, open, size } = state;
+    const accordionHeader = _react.useMemo(()=>({
+            disabled,
+            expandIconPosition,
+            open,
+            size
+        }), [
+        disabled,
+        expandIconPosition,
+        open,
+        size
+    ]);
+    return {
+        accordionHeader
+    };
+}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/useAccordionHeaderContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionHeader/useAccordionHeaderContextValues.ts"],"sourcesContent":["import * as React from 'react';\nimport type { AccordionHeaderState, AccordionHeaderContextValues } from './AccordionHeader.types';\nimport type { AccordionHeaderContextValue } from '../../contexts/accordionHeader';\n\nexport function useAccordionHeaderContextValues_unstable(state: AccordionHeaderState): AccordionHeaderContextValues {\n  const { disabled, expandIconPosition, open, size } = state;\n\n  const accordionHeader = React.useMemo<AccordionHeaderContextValue>(\n    () => ({\n      disabled,\n      expandIconPosition,\n      open,\n      size,\n    }),\n    [disabled, expandIconPosition, open, size],\n  );\n\n  return { accordionHeader };\n}\n"],"names":["useAccordionHeaderContextValues_unstable","state","disabled","expandIconPosition","open","size","accordionHeader","React","useMemo"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIgBA;;;eAAAA;;;;iEAJO;AAIhB,SAASA,yCAAyCC,KAA2B;IAClF,MAAM,EAAEC,QAAQ,EAAEC,kBAAkB,EAAEC,IAAI,EAAEC,IAAI,EAAE,GAAGJ;IAErD,MAAMK,kBAAkBC,OAAMC,OAAO,CACnC,IAAO,CAAA;YACLN;YACAC;YACAC;YACAC;QACF,CAAA,GACA;QAACH;QAAUC;QAAoBC;QAAMC;KAAK;IAG5C,OAAO;QAAEC;IAAgB;AAC3B"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionHeader/useAccordionHeaderStyles.styles.js

@@ -0,0 +1,371 @@
+"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, {
+    accordionHeaderClassNames: function() {
+        return accordionHeaderClassNames;
+    },
+    useAccordionHeaderStyles_unstable: function() {
+        return useAccordionHeaderStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const accordionHeaderClassNames = {
+    root: 'fui-AccordionHeader',
+    button: 'fui-AccordionHeader__button',
+    expandIcon: 'fui-AccordionHeader__expandIcon',
+    icon: 'fui-AccordionHeader__icon'
+};
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    resetButton: {
+        B7ck84d: "f1e4lqlz",
+        De3pzq: "f1u2r49w",
+        sj55zd: "f1ym3bx4",
+        Bahqtrf: "f1mo0ibp",
+        Be2twd7: "fjoy568",
+        Bg96gwp: "fytdu2e",
+        B68tc82: 0,
+        Bmxbyg5: 0,
+        Bpg54ce: "f1gl81tg",
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "f1mk8lai",
+        Bv0vk6g: "f37px4s",
+        fsow6f: "fgusgyc"
+    },
+    focusIndicator: {
+        Brovlpu: "ftqa4ok",
+        B486eqv: "f2hkw1w",
+        B8q5s1w: "f8hki3x",
+        Bci5o5g: [
+            "f1d2448m",
+            "ffh67wi"
+        ],
+        n8qw10: "f1bjia2o",
+        Bdrgwmp: [
+            "ffh67wi",
+            "f1d2448m"
+        ],
+        Bb7d1vk: "f226i61",
+        zhwhgb: [
+            "f13kzufm",
+            "fsx75g8"
+        ],
+        dhy2o1: "flujwa2",
+        Gfyso: [
+            "fsx75g8",
+            "f13kzufm"
+        ],
+        Bm4h7ae: "f15bsgw9",
+        B7ys5i9: "f14e48fq",
+        Busjfv9: "f18yb2kv",
+        Bhk32uz: "fd6o370",
+        f6g5ot: 0,
+        Boxcth7: 0,
+        Bhdgwq3: 0,
+        hgwjuy: 0,
+        Bshpdp8: 0,
+        Bsom6fd: 0,
+        Blkhhs4: 0,
+        Bonggc9: 0,
+        Ddfuxk: 0,
+        i03rao: 0,
+        kclons: 0,
+        clg4pj: 0,
+        Bpqj9nj: 0,
+        B6dhp37: 0,
+        Bf4ptjt: 0,
+        Bqtpl0w: 0,
+        i4rwgc: "ffwy5si",
+        Dah5zi: 0,
+        B1tsrr9: 0,
+        qqdqy8: 0,
+        Bkh64rk: 0,
+        e3fwne: "f3znvyf",
+        J0r882: "f57olzd",
+        Bule8hv: [
+            "f4stah7",
+            "fs1por5"
+        ],
+        Bjwuhne: "f480a47",
+        Ghsupd: [
+            "fs1por5",
+            "f4stah7"
+        ]
+    },
+    root: {
+        sj55zd: "f19n0e5",
+        De3pzq: "f1c21dwh",
+        jrapky: 0,
+        Frg6f3: 0,
+        t21cq0: 0,
+        B6of3ja: 0,
+        B74szlk: "f1s184ao",
+        Beyfa6y: 0,
+        Bbmb7ep: 0,
+        Btl43ni: 0,
+        B7oj6ja: 0,
+        Dimara: "ft85np5"
+    },
+    rootDisabled: {
+        Bcmaq0h: "fwrgwhw",
+        sj55zd: "f1s2aq7o"
+    },
+    rootInline: {
+        mc9l5x: "f14t3ns0"
+    },
+    button: {
+        qhf8xq: "f10pi13n",
+        a9b677: "fly5x3f",
+        B4j52fo: "fre7gi1",
+        Bekrc4i: [
+            "f1358rze",
+            "f1rvrf73"
+        ],
+        Bn0qgzm: "fqdk4by",
+        ibv6hh: [
+            "f1rvrf73",
+            "f1358rze"
+        ],
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: [
+            "f1rmphuq",
+            "f26yw9j"
+        ],
+        sshi5w: "f5pgtk9",
+        mc9l5x: "f22iagw",
+        Bt984gj: "f122n59",
+        Bceei9c: "f1k6fduh",
+        Bahqtrf: "fk6fouc",
+        Be2twd7: "fkhj508",
+        Bhrd7zp: "figsok6",
+        Bg96gwp: "f1i3iumi",
+        B7ck84d: "f1ewtqcl"
+    },
+    buttonSmall: {
+        sshi5w: "f1nxs5xn",
+        Be2twd7: "fy9rknc"
+    },
+    buttonLarge: {
+        Bg96gwp: "faaz57k",
+        Be2twd7: "fod5ikn"
+    },
+    buttonExtraLarge: {
+        Bg96gwp: "f106mvju",
+        Be2twd7: "f1pp30po"
+    },
+    buttonInline: {
+        mc9l5x: "ftuwxu6"
+    },
+    buttonExpandIconEndNoIcon: {
+        uwmqm3: [
+            "f1uw59to",
+            "fw5db7e"
+        ]
+    },
+    buttonExpandIconEnd: {
+        z189sj: [
+            "f11gcy0p",
+            "f1ng84yb"
+        ]
+    },
+    buttonDisabled: {
+        Bceei9c: "fdrzuqr"
+    },
+    expandIcon: {
+        Bqenvij: "f1l02sjl",
+        mc9l5x: "f22iagw",
+        Bt984gj: "f122n59",
+        Bg96gwp: "f106mvju",
+        Be2twd7: "f1pp30po"
+    },
+    expandIconStart: {
+        z189sj: [
+            "f1vdfbxk",
+            "f1f5gg8d"
+        ]
+    },
+    expandIconEnd: {
+        Bh6795r: "fqerorx",
+        Bnnss6s: "f1neuvcm",
+        xawz: "flqd7gy",
+        mc9l5x: "f22iagw",
+        Brf1p80: "f9c4gz4",
+        uwmqm3: [
+            "f1f5gg8d",
+            "f1vdfbxk"
+        ]
+    },
+    icon: {
+        Bqenvij: "f1l02sjl",
+        mc9l5x: "f22iagw",
+        Bt984gj: "f122n59",
+        z189sj: [
+            "f1vdfbxk",
+            "f1f5gg8d"
+        ],
+        Bg96gwp: "f106mvju",
+        Be2twd7: "f1pp30po"
+    }
+}, {
+    d: [
+        ".f1e4lqlz{box-sizing:content-box;}",
+        ".f1u2r49w{background-color:inherit;}",
+        ".f1ym3bx4{color:inherit;}",
+        ".f1mo0ibp{font-family:inherit;}",
+        ".fjoy568{font-size:inherit;}",
+        ".fytdu2e{line-height:normal;}",
+        [
+            ".f1gl81tg{overflow:visible;}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".f1mk8lai{padding:0;}",
+            {
+                p: -1
+            }
+        ],
+        ".f37px4s{-webkit-appearance:button;}",
+        ".fgusgyc{text-align:unset;}",
+        ".f8hki3x[data-fui-focus-visible]{border-top-color:transparent;}",
+        ".f1d2448m[data-fui-focus-visible]{border-right-color:transparent;}",
+        ".ffh67wi[data-fui-focus-visible]{border-left-color:transparent;}",
+        ".f1bjia2o[data-fui-focus-visible]{border-bottom-color:transparent;}",
+        ".f15bsgw9[data-fui-focus-visible]::after{content:\"\";}",
+        ".f14e48fq[data-fui-focus-visible]::after{position:absolute;}",
+        ".f18yb2kv[data-fui-focus-visible]::after{pointer-events:none;}",
+        ".fd6o370[data-fui-focus-visible]::after{z-index:1;}",
+        [
+            ".ffwy5si[data-fui-focus-visible]::after{border:2px solid var(--colorStrokeFocus2);}",
+            {
+                p: -2
+            }
+        ],
+        [
+            ".f3znvyf[data-fui-focus-visible]::after{border-radius:var(--borderRadiusMedium);}",
+            {
+                p: -1
+            }
+        ],
+        ".f57olzd[data-fui-focus-visible]::after{top:calc(2px * -1);}",
+        ".f4stah7[data-fui-focus-visible]::after{right:calc(2px * -1);}",
+        ".fs1por5[data-fui-focus-visible]::after{left:calc(2px * -1);}",
+        ".f480a47[data-fui-focus-visible]::after{bottom:calc(2px * -1);}",
+        ".f19n0e5{color:var(--colorNeutralForeground1);}",
+        ".f1c21dwh{background-color:var(--colorTransparentBackground);}",
+        [
+            ".f1s184ao{margin:0;}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".ft85np5{border-radius:var(--borderRadiusMedium);}",
+            {
+                p: -1
+            }
+        ],
+        ".fwrgwhw{background-image:none;}",
+        ".f1s2aq7o{color:var(--colorNeutralForegroundDisabled);}",
+        ".f14t3ns0{display:inline-block;}",
+        ".f10pi13n{position:relative;}",
+        ".fly5x3f{width:100%;}",
+        ".fre7gi1{border-top-width:0;}",
+        ".f1358rze{border-right-width:0;}",
+        ".f1rvrf73{border-left-width:0;}",
+        ".fqdk4by{border-bottom-width:0;}",
+        [
+            ".f1rmphuq{padding:0 var(--spacingHorizontalM) 0 var(--spacingHorizontalMNudge);}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".f26yw9j{padding:0 var(--spacingHorizontalMNudge) 0 var(--spacingHorizontalM);}",
+            {
+                p: -1
+            }
+        ],
+        ".f5pgtk9{min-height:44px;}",
+        ".f22iagw{display:flex;}",
+        ".f122n59{align-items:center;}",
+        ".f1k6fduh{cursor:pointer;}",
+        ".fk6fouc{font-family:var(--fontFamilyBase);}",
+        ".fkhj508{font-size:var(--fontSizeBase300);}",
+        ".figsok6{font-weight:var(--fontWeightRegular);}",
+        ".f1i3iumi{line-height:var(--lineHeightBase300);}",
+        ".f1ewtqcl{box-sizing:border-box;}",
+        ".f1nxs5xn{min-height:32px;}",
+        ".fy9rknc{font-size:var(--fontSizeBase200);}",
+        ".faaz57k{line-height:var(--lineHeightBase400);}",
+        ".fod5ikn{font-size:var(--fontSizeBase400);}",
+        ".f106mvju{line-height:var(--lineHeightBase500);}",
+        ".f1pp30po{font-size:var(--fontSizeBase500);}",
+        ".ftuwxu6{display:inline-flex;}",
+        ".f1uw59to{padding-left:var(--spacingHorizontalM);}",
+        ".fw5db7e{padding-right:var(--spacingHorizontalM);}",
+        ".f11gcy0p{padding-right:var(--spacingHorizontalMNudge);}",
+        ".f1ng84yb{padding-left:var(--spacingHorizontalMNudge);}",
+        ".fdrzuqr{cursor:not-allowed;}",
+        ".f1l02sjl{height:100%;}",
+        ".f1vdfbxk{padding-right:var(--spacingHorizontalS);}",
+        ".f1f5gg8d{padding-left:var(--spacingHorizontalS);}",
+        ".fqerorx{flex-grow:1;}",
+        ".f1neuvcm{flex-shrink:1;}",
+        ".flqd7gy{flex-basis:0%;}",
+        ".f9c4gz4{justify-content:flex-end;}"
+    ],
+    f: [
+        ".ftqa4ok:focus{outline-style:none;}"
+    ],
+    i: [
+        ".f2hkw1w:focus-visible{outline-style:none;}"
+    ],
+    m: [
+        [
+            "@media (forced-colors: active){.f226i61[data-fui-focus-visible]::after{border-top-color:Highlight;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.f13kzufm[data-fui-focus-visible]::after{border-right-color:Highlight;}.fsx75g8[data-fui-focus-visible]::after{border-left-color:Highlight;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.flujwa2[data-fui-focus-visible]::after{border-bottom-color:Highlight;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ]
+    ]
+});
+const useAccordionHeaderStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    state.root.className = (0, _react.mergeClasses)(accordionHeaderClassNames.root, styles.root, state.inline && styles.rootInline, state.disabled && styles.rootDisabled, state.root.className);
+    state.button.className = (0, _react.mergeClasses)(accordionHeaderClassNames.button, styles.resetButton, styles.button, styles.focusIndicator, state.expandIconPosition === 'end' && !state.icon && styles.buttonExpandIconEndNoIcon, state.expandIconPosition === 'end' && styles.buttonExpandIconEnd, state.inline && styles.buttonInline, state.size === 'small' && styles.buttonSmall, state.size === 'large' && styles.buttonLarge, state.size === 'extra-large' && styles.buttonExtraLarge, state.disabled && styles.buttonDisabled, state.button.className);
+    if (state.expandIcon) {
+        state.expandIcon.className = (0, _react.mergeClasses)(accordionHeaderClassNames.expandIcon, styles.expandIcon, state.expandIconPosition === 'start' && styles.expandIconStart, state.expandIconPosition === 'end' && styles.expandIconEnd, state.expandIcon.className);
+    }
+    if (state.icon) {
+        state.icon.className = (0, _react.mergeClasses)(accordionHeaderClassNames.icon, styles.icon, state.icon.className);
+    }
+    return state;
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/AccordionItem.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AccordionItem", {
+    enumerable: true,
+    get: function() {
+        return AccordionItem;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useAccordionItem = require("./useAccordionItem");
+const _useAccordionItemContextValues = require("./useAccordionItemContextValues");
+const _renderAccordionItem = require("./renderAccordionItem");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _useAccordionItemStylesstyles = require("./useAccordionItemStyles.styles");
+const AccordionItem = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useAccordionItem.useAccordionItem_unstable)(props, ref);
+    const contextValues = (0, _useAccordionItemContextValues.useAccordionItemContextValues_unstable)(state);
+    (0, _useAccordionItemStylesstyles.useAccordionItemStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useAccordionItemStyles_unstable')(state);
+    return (0, _renderAccordionItem.renderAccordionItem_unstable)(state, contextValues);
+});
+AccordionItem.displayName = 'AccordionItem';

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/AccordionItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionItem/AccordionItem.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useAccordionItem_unstable } from './useAccordionItem';\nimport { useAccordionItemContextValues_unstable } from './useAccordionItemContextValues';\nimport { renderAccordionItem_unstable } from './renderAccordionItem';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\nimport { useAccordionItemStyles_unstable } from './useAccordionItemStyles.styles';\nimport type { AccordionItemProps } from './AccordionItem.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\n\n/**\n * Define a styled AccordionItem, using the `useAccordionItem_unstable` and `useAccordionItemStyles_unstable` hooks.\n */\nexport const AccordionItem: ForwardRefComponent<AccordionItemProps> = React.forwardRef((props, ref) => {\n  const state = useAccordionItem_unstable(props, ref);\n  const contextValues = useAccordionItemContextValues_unstable(state);\n\n  useAccordionItemStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useAccordionItemStyles_unstable')(state);\n\n  return renderAccordionItem_unstable(state, contextValues);\n});\n\nAccordionItem.displayName = 'AccordionItem';\n"],"names":["AccordionItem","React","forwardRef","props","ref","state","useAccordionItem_unstable","contextValues","useAccordionItemContextValues_unstable","useAccordionItemStyles_unstable","useCustomStyleHook_unstable","renderAccordionItem_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;kCACmB;+CACa;qCACV;qCACD;8CACI;AAOzC,MAAMA,gBAAAA,WAAAA,GAAyDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC7F,MAAMC,QAAQC,IAAAA,2CAAAA,EAA0BH,OAAOC;IAC/C,MAAMG,gBAAgBC,IAAAA,qEAAAA,EAAuCH;IAE7DI,IAAAA,6DAAAA,EAAgCJ;IAEhCK,IAAAA,gDAAAA,EAA4B,mCAAmCL;IAE/D,OAAOM,IAAAA,iDAAAA,EAA6BN,OAAOE;AAC7C;AAEAP,cAAcY,WAAW,GAAG"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/AccordionItem.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/AccordionItem.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionItem/AccordionItem.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport { AccordionItemContextValue } from '../../contexts/accordionItem';\n\nexport type AccordionItemContextValues<Value = AccordionItemValue> = {\n  accordionItem: AccordionItemContextValue<Value>;\n};\n\nexport type AccordionItemSlots = {\n  root: NonNullable<Slot<'div'>>;\n};\n\nexport type AccordionItemProps<Value = AccordionItemValue> = ComponentProps<AccordionItemSlots> & {\n  /**\n   * Disables opening/closing of panel.\n   */\n  disabled?: boolean;\n  /**\n   * Required value that identifies this item inside an Accordion component.\n   */\n  value: Value;\n};\n\nexport type AccordionItemValue = unknown;\n\nexport type AccordionItemState<Value = AccordionItemValue> = ComponentState<AccordionItemSlots> &\n  AccordionItemContextValue<Value>;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/index.js

@@ -0,0 +1,35 @@
+"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, {
+    AccordionItem: function() {
+        return _AccordionItem.AccordionItem;
+    },
+    accordionItemClassNames: function() {
+        return _useAccordionItemStylesstyles.accordionItemClassNames;
+    },
+    renderAccordionItem_unstable: function() {
+        return _renderAccordionItem.renderAccordionItem_unstable;
+    },
+    useAccordionItemContextValues_unstable: function() {
+        return _useAccordionItemContextValues.useAccordionItemContextValues_unstable;
+    },
+    useAccordionItemStyles_unstable: function() {
+        return _useAccordionItemStylesstyles.useAccordionItemStyles_unstable;
+    },
+    useAccordionItem_unstable: function() {
+        return _useAccordionItem.useAccordionItem_unstable;
+    }
+});
+const _AccordionItem = require("./AccordionItem");
+const _renderAccordionItem = require("./renderAccordionItem");
+const _useAccordionItem = require("./useAccordionItem");
+const _useAccordionItemContextValues = require("./useAccordionItemContextValues");
+const _useAccordionItemStylesstyles = require("./useAccordionItemStyles.styles");

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionItem/index.ts"],"sourcesContent":["export { AccordionItem } from './AccordionItem';\nexport type {\n  AccordionItemContextValues,\n  AccordionItemProps,\n  AccordionItemSlots,\n  AccordionItemState,\n  AccordionItemValue,\n} from './AccordionItem.types';\nexport { renderAccordionItem_unstable } from './renderAccordionItem';\nexport { useAccordionItem_unstable } from './useAccordionItem';\nexport { useAccordionItemContextValues_unstable } from './useAccordionItemContextValues';\nexport { accordionItemClassNames, useAccordionItemStyles_unstable } from './useAccordionItemStyles.styles';\n"],"names":["AccordionItem","accordionItemClassNames","renderAccordionItem_unstable","useAccordionItemContextValues_unstable","useAccordionItemStyles_unstable","useAccordionItem_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,aAAa;eAAbA,4BAAa;;IAWbC,uBAAuB;eAAvBA,qDAAuB;;IAHvBC,4BAA4B;eAA5BA,iDAA4B;;IAE5BC,sCAAsC;eAAtCA,qEAAsC;;IACbC,+BAA+B;eAA/BA,6DAA+B;;IAFxDC,yBAAyB;eAAzBA,2CAAyB;;;+BATJ;qCAQe;kCACH;+CACa;8CACkB"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/renderAccordionItem.js

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

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/renderAccordionItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionItem/renderAccordionItem.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { AccordionItemState, AccordionItemSlots, AccordionItemContextValues } from './AccordionItem.types';\nimport { AccordionItemProvider } from '../../contexts/accordionItem';\n\n/**\n * Function that renders the final JSX of the component\n */\nexport const renderAccordionItem_unstable = (state: AccordionItemState, contextValues: AccordionItemContextValues) => {\n  assertSlots<AccordionItemSlots>(state);\n\n  return (\n    <state.root>\n      <AccordionItemProvider value={contextValues.accordionItem}>{state.root.children}</AccordionItemProvider>\n    </state.root>\n  );\n};\n"],"names":["renderAccordionItem_unstable","state","contextValues","assertSlots","_jsx","root","AccordionItemProvider","value","accordionItem","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;4BATb;gCAE4B;+BAEU;AAK/B,MAAMA,+BAA+B,CAACC,OAA2BC;IACtEC,IAAAA,2BAAAA,EAAgCF;IAEhC,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACH,MAAMI,IAAI,EAAA;kBACT,WAAA,GAAAD,IAAAA,eAAA,EAACE,oCAAAA,EAAAA;YAAsBC,OAAOL,cAAcM,aAAa;sBAAGP,MAAMI,IAAI,CAACI,QAAQ;;;AAGrF"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/useAccordionItem.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordionItem_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordionItem_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _accordion = require("../../contexts/accordion");
+const useAccordionItem_unstable = (props, ref)=>{
+    const { value, disabled = false } = props;
+    const requestToggle = (0, _accordion.useAccordionContext_unstable)((ctx)=>ctx.requestToggle);
+    const open = (0, _accordion.useAccordionContext_unstable)((ctx)=>ctx.openItems.includes(value));
+    const onAccordionHeaderClick = (0, _reactutilities.useEventCallback)((event)=>requestToggle({
+            event,
+            value
+        }));
+    return {
+        open,
+        value,
+        disabled,
+        onHeaderClick: onAccordionHeaderClick,
+        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: ref,
+            ...props
+        }), {
+            elementType: 'div'
+        })
+    };
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/useAccordionItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionItem/useAccordionItem.ts"],"sourcesContent":["import * as React from 'react';\nimport { getIntrinsicElementProps, slot, useEventCallback } from '@fluentui/react-utilities';\nimport type { AccordionItemProps, AccordionItemState } from './AccordionItem.types';\nimport type { AccordionToggleEvent } from '../Accordion/Accordion.types';\nimport { useAccordionContext_unstable } from '../../contexts/accordion';\n\n/**\n * Returns the props and state required to render the component\n * @param props - AccordionItem properties\n * @param ref - reference to root HTMLElement of AccordionItem\n */\nexport const useAccordionItem_unstable = (\n  props: AccordionItemProps,\n  ref: React.Ref<HTMLElement>,\n): AccordionItemState => {\n  const { value, disabled = false } = props;\n\n  const requestToggle = useAccordionContext_unstable(ctx => ctx.requestToggle);\n  const open = useAccordionContext_unstable(ctx => ctx.openItems.includes(value));\n  const onAccordionHeaderClick = useEventCallback((event: AccordionToggleEvent) => requestToggle({ event, value }));\n\n  return {\n    open,\n    value,\n    disabled,\n    onHeaderClick: onAccordionHeaderClick,\n    components: {\n      root: 'div',\n    },\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n  };\n};\n"],"names":["useAccordionItem_unstable","props","ref","value","disabled","requestToggle","useAccordionContext_unstable","ctx","open","openItems","includes","onAccordionHeaderClick","useEventCallback","event","onHeaderClick","components","root","slot","always","getIntrinsicElementProps","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;gCAC0C;2BAGpB;AAOtC,MAAMA,4BAA4B,CACvCC,OACAC;IAEA,MAAM,EAAEC,KAAK,EAAEC,WAAW,KAAK,EAAE,GAAGH;IAEpC,MAAMI,gBAAgBC,IAAAA,uCAAAA,EAA6BC,CAAAA,MAAOA,IAAIF,aAAa;IAC3E,MAAMG,OAAOF,IAAAA,uCAAAA,EAA6BC,CAAAA,MAAOA,IAAIE,SAAS,CAACC,QAAQ,CAACP;IACxE,MAAMQ,yBAAyBC,IAAAA,gCAAAA,EAAiB,CAACC,QAAgCR,cAAc;YAAEQ;YAAOV;QAAM;IAE9G,OAAO;QACLK;QACAL;QACAC;QACAU,eAAeH;QACfI,YAAY;YACVC,MAAM;QACR;QACAA,MAAMC,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,OAAO;YAC9B,SAAS;YACT,4EAA4E;YAC5E,4FAA4F;YAC5FjB,KAAKA;YACL,GAAGD,KAAK;QACV,IACA;YAAEmB,aAAa;QAAM;IAEzB;AACF"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/useAccordionItemContextValues.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordionItemContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordionItemContextValues_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+function useAccordionItemContextValues_unstable(state) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    const { disabled, open, value, onHeaderClick } = state;
+    const accordionItem = _react.useMemo(()=>({
+            disabled,
+            open,
+            value,
+            onHeaderClick
+        }), [
+        disabled,
+        open,
+        value,
+        onHeaderClick
+    ]);
+    return {
+        accordionItem
+    };
+}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/useAccordionItemContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionItem/useAccordionItemContextValues.ts"],"sourcesContent":["import * as React from 'react';\nimport type { AccordionItemContextValues, AccordionItemState } from './AccordionItem.types';\nimport { AccordionItemContextValue } from '../../contexts/accordionItem';\n\nexport function useAccordionItemContextValues_unstable(state: AccordionItemState): AccordionItemContextValues {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const { disabled, open, value, onHeaderClick } = state;\n  const accordionItem = React.useMemo<AccordionItemContextValue>(\n    () => ({ disabled, open, value, onHeaderClick }),\n    [disabled, open, value, onHeaderClick],\n  );\n\n  return { accordionItem };\n}\n"],"names":["useAccordionItemContextValues_unstable","state","disabled","open","value","onHeaderClick","accordionItem","React","useMemo"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIgBA;;;eAAAA;;;;iEAJO;AAIhB,SAASA,uCAAuCC,KAAyB;IAC9E,4DAA4D;IAC5D,MAAM,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,KAAK,EAAEC,aAAa,EAAE,GAAGJ;IACjD,MAAMK,gBAAgBC,OAAMC,OAAO,CACjC,IAAO,CAAA;YAAEN;YAAUC;YAAMC;YAAOC;QAAc,CAAA,GAC9C;QAACH;QAAUC;QAAMC;QAAOC;KAAc;IAGxC,OAAO;QAAEC;IAAc;AACzB"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/useAccordionItemStyles.styles.js

@@ -0,0 +1,27 @@
+"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, {
+    accordionItemClassNames: function() {
+        return accordionItemClassNames;
+    },
+    useAccordionItemStyles_unstable: function() {
+        return useAccordionItemStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const accordionItemClassNames = {
+    root: 'fui-AccordionItem'
+};
+const useAccordionItemStyles_unstable = (state)=>{
+    'use no memo';
+    state.root.className = (0, _react.mergeClasses)(accordionItemClassNames.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionItem/useAccordionItemStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useAccordionItemStyles.styles.js"],"sourcesContent":["import { mergeClasses } from '@griffel/react';\nexport const accordionItemClassNames = {\n    root: 'fui-AccordionItem'\n};\nexport const useAccordionItemStyles_unstable = (state)=>{\n    'use no memo';\n    state.root.className = mergeClasses(accordionItemClassNames.root, state.root.className);\n    return state;\n};\n"],"names":["accordionItemClassNames","useAccordionItemStyles_unstable","root","state","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACaA,uBAAuB;eAAvBA;;IAGAC,+BAA+B;eAA/BA;;;uBAJgB;AACtB,MAAMD,0BAA0B;IACnCE,MAAM;AACV;AACO,MAAMD,kCAAmCE,CAAAA;IAC5C;IACAA,MAAMD,IAAI,CAACE,SAAS,GAAGC,IAAAA,mBAAY,EAACL,wBAAwBE,IAAI,EAAEC,MAAMD,IAAI,CAACE,SAAS;IACtF,OAAOD;AACX"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/AccordionPanel.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AccordionPanel", {
+    enumerable: true,
+    get: function() {
+        return AccordionPanel;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useAccordionPanel = require("./useAccordionPanel");
+const _renderAccordionPanel = require("./renderAccordionPanel");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _useAccordionPanelStylesstyles = require("./useAccordionPanelStyles.styles");
+const AccordionPanel = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useAccordionPanel.useAccordionPanel_unstable)(props, ref);
+    (0, _useAccordionPanelStylesstyles.useAccordionPanelStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useAccordionPanelStyles_unstable')(state);
+    return (0, _renderAccordionPanel.renderAccordionPanel_unstable)(state);
+});
+AccordionPanel.displayName = 'AccordionPanel';

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/AccordionPanel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionPanel/AccordionPanel.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useAccordionPanel_unstable } from './useAccordionPanel';\nimport { renderAccordionPanel_unstable } from './renderAccordionPanel';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\nimport { useAccordionPanelStyles_unstable } from './useAccordionPanelStyles.styles';\nimport type { AccordionPanelProps } from './AccordionPanel.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\n\n/**\n * Define a styled AccordionPanel, using the `useAccordionPanel_unstable` and `useAccordionPanelStyles_unstable` hooks.\n */\nexport const AccordionPanel: ForwardRefComponent<AccordionPanelProps> = React.forwardRef((props, ref) => {\n  const state = useAccordionPanel_unstable(props, ref);\n\n  useAccordionPanelStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useAccordionPanelStyles_unstable')(state);\n\n  return renderAccordionPanel_unstable(state);\n});\n\nAccordionPanel.displayName = 'AccordionPanel';\n"],"names":["AccordionPanel","React","forwardRef","props","ref","state","useAccordionPanel_unstable","useAccordionPanelStyles_unstable","useCustomStyleHook_unstable","renderAccordionPanel_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;mCACoB;sCACG;qCACF;+CACK;AAO1C,MAAMA,iBAAAA,WAAAA,GAA2DC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC/F,MAAMC,QAAQC,IAAAA,6CAAAA,EAA2BH,OAAOC;IAEhDG,IAAAA,+DAAAA,EAAiCF;IAEjCG,IAAAA,gDAAAA,EAA4B,oCAAoCH;IAEhE,OAAOI,IAAAA,mDAAAA,EAA8BJ;AACvC;AAEAL,eAAeU,WAAW,GAAG"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/AccordionPanel.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/AccordionPanel.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionPanel/AccordionPanel.types.ts"],"sourcesContent":["import type { PresenceMotionSlotProps } from '@fluentui/react-motion';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type AccordionPanelSlots = {\n  root: NonNullable<Slot<'div'>>;\n  collapseMotion?: Slot<PresenceMotionSlotProps>;\n};\n\nexport type AccordionPanelProps = ComponentProps<AccordionPanelSlots>;\n\nexport type AccordionPanelState = ComponentState<AccordionPanelSlots> & {\n  /**\n   * Internal open state, provided by context.\n   */\n  open: boolean;\n};\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/index.js

@@ -0,0 +1,31 @@
+"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, {
+    AccordionPanel: function() {
+        return _AccordionPanel.AccordionPanel;
+    },
+    accordionPanelClassNames: function() {
+        return _useAccordionPanelStylesstyles.accordionPanelClassNames;
+    },
+    renderAccordionPanel_unstable: function() {
+        return _renderAccordionPanel.renderAccordionPanel_unstable;
+    },
+    useAccordionPanelStyles_unstable: function() {
+        return _useAccordionPanelStylesstyles.useAccordionPanelStyles_unstable;
+    },
+    useAccordionPanel_unstable: function() {
+        return _useAccordionPanel.useAccordionPanel_unstable;
+    }
+});
+const _AccordionPanel = require("./AccordionPanel");
+const _renderAccordionPanel = require("./renderAccordionPanel");
+const _useAccordionPanel = require("./useAccordionPanel");
+const _useAccordionPanelStylesstyles = require("./useAccordionPanelStyles.styles");

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionPanel/index.ts"],"sourcesContent":["export { AccordionPanel } from './AccordionPanel';\nexport type { AccordionPanelProps, AccordionPanelSlots, AccordionPanelState } from './AccordionPanel.types';\nexport { renderAccordionPanel_unstable } from './renderAccordionPanel';\nexport { useAccordionPanel_unstable } from './useAccordionPanel';\nexport { accordionPanelClassNames, useAccordionPanelStyles_unstable } from './useAccordionPanelStyles.styles';\n"],"names":["AccordionPanel","accordionPanelClassNames","renderAccordionPanel_unstable","useAccordionPanelStyles_unstable","useAccordionPanel_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,cAAc;eAAdA,8BAAc;;IAIdC,wBAAwB;eAAxBA,uDAAwB;;IAFxBC,6BAA6B;eAA7BA,mDAA6B;;IAEHC,gCAAgC;eAAhCA,+DAAgC;;IAD1DC,0BAA0B;eAA1BA,6CAA0B;;;gCAHJ;sCAEe;mCACH;+CACgC"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/renderAccordionPanel.js

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

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/renderAccordionPanel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionPanel/renderAccordionPanel.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { AccordionPanelState, AccordionPanelSlots } from './AccordionPanel.types';\n\n/**\n * Function that renders the final JSX of the component\n */\nexport const renderAccordionPanel_unstable = (state: AccordionPanelState) => {\n  assertSlots<AccordionPanelSlots>(state);\n  return state.collapseMotion ? (\n    <state.collapseMotion>\n      <state.root />\n    </state.collapseMotion>\n  ) : (\n    <state.root />\n  );\n};\n"],"names":["renderAccordionPanel_unstable","state","assertSlots","collapseMotion","_jsx","root"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAE4B;AAMrB,MAAMA,gCAAgC,CAACC;IAC5CC,IAAAA,2BAAAA,EAAiCD;IACjC,OAAOA,MAAME,cAAc,GAAA,WAAA,GACzBC,IAAAA,eAAA,EAACH,MAAME,cAAc,EAAA;kBACnB,WAAA,GAAAC,IAAAA,eAAA,EAACH,MAAMI,IAAI,EAAA,CAAA;uBAGbD,IAAAA,eAAA,EAACH,MAAMI,IAAI,EAAA,CAAA;AAEf"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/useAccordionPanel.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAccordionPanel_unstable", {
+    enumerable: true,
+    get: function() {
+        return useAccordionPanel_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reacttabster = require("@fluentui/react-tabster");
+const _reactmotion = require("@fluentui/react-motion");
+const _reactmotioncomponentspreview = require("@fluentui/react-motion-components-preview");
+const _accordion = require("../../contexts/accordion");
+const _accordionItem = require("../../contexts/accordionItem");
+const useAccordionPanel_unstable = (props, ref)=>{
+    const { open } = (0, _accordionItem.useAccordionItemContext_unstable)();
+    const focusableProps = (0, _reacttabster.useTabsterAttributes)({
+        focusable: {
+            excludeFromMover: true
+        }
+    });
+    const navigation = (0, _accordion.useAccordionContext_unstable)((ctx)=>ctx.navigation);
+    return {
+        open,
+        components: {
+            root: 'div',
+            // TODO: remove once React v18 slot API is modified
+            // This is a problem at the moment due to UnknownSlotProps assumption
+            // that `children` property is `ReactNode`, which in this case is not valid
+            // as PresenceComponentProps['children'] is `ReactElement`
+            collapseMotion: _reactmotioncomponentspreview.Collapse
+        },
+        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: ref,
+            ...props,
+            ...navigation && focusableProps
+        }), {
+            elementType: 'div'
+        }),
+        collapseMotion: (0, _reactmotion.presenceMotionSlot)(props.collapseMotion, {
+            elementType: _reactmotioncomponentspreview.Collapse,
+            defaultProps: {
+                visible: open,
+                unmountOnExit: true
+            }
+        })
+    };
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/useAccordionPanel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/AccordionPanel/useAccordionPanel.ts"],"sourcesContent":["import * as React from 'react';\nimport { getIntrinsicElementProps, slot } from '@fluentui/react-utilities';\nimport { useTabsterAttributes } from '@fluentui/react-tabster';\nimport { presenceMotionSlot, type PresenceMotionSlotProps } from '@fluentui/react-motion';\nimport { Collapse } from '@fluentui/react-motion-components-preview';\nimport { useAccordionContext_unstable } from '../../contexts/accordion';\nimport type { AccordionPanelProps, AccordionPanelState } from './AccordionPanel.types';\nimport { useAccordionItemContext_unstable } from '../../contexts/accordionItem';\n\n/**\n * Returns the props and state required to render the component\n * @param props - AccordionPanel properties\n * @param ref - reference to root HTMLElement of AccordionPanel\n */\nexport const useAccordionPanel_unstable = (\n  props: AccordionPanelProps,\n  ref: React.Ref<HTMLElement>,\n): AccordionPanelState => {\n  const { open } = useAccordionItemContext_unstable();\n  const focusableProps = useTabsterAttributes({ focusable: { excludeFromMover: true } });\n  const navigation = useAccordionContext_unstable(ctx => ctx.navigation);\n\n  return {\n    open,\n    components: {\n      root: 'div',\n      // TODO: remove once React v18 slot API is modified\n      // This is a problem at the moment due to UnknownSlotProps assumption\n      // that `children` property is `ReactNode`, which in this case is not valid\n      // as PresenceComponentProps['children'] is `ReactElement`\n      collapseMotion: Collapse as React.FC<PresenceMotionSlotProps>,\n    },\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        ...props,\n        ...(navigation && focusableProps),\n      }),\n      { elementType: 'div' },\n    ),\n    collapseMotion: presenceMotionSlot(props.collapseMotion, {\n      elementType: Collapse,\n      defaultProps: {\n        visible: open,\n        unmountOnExit: true,\n      },\n    }),\n  };\n};\n"],"names":["useAccordionPanel_unstable","props","ref","open","useAccordionItemContext_unstable","focusableProps","useTabsterAttributes","focusable","excludeFromMover","navigation","useAccordionContext_unstable","ctx","components","root","collapseMotion","Collapse","slot","always","getIntrinsicElementProps","elementType","presenceMotionSlot","defaultProps","visible","unmountOnExit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAcaA;;;eAAAA;;;;iEAdU;gCACwB;8BACV;6BAC4B;8CACxC;2BACoB;+BAEI;AAO1C,MAAMA,6BAA6B,CACxCC,OACAC;IAEA,MAAM,EAAEC,IAAI,EAAE,GAAGC,IAAAA,+CAAAA;IACjB,MAAMC,iBAAiBC,IAAAA,kCAAAA,EAAqB;QAAEC,WAAW;YAAEC,kBAAkB;QAAK;IAAE;IACpF,MAAMC,aAAaC,IAAAA,uCAAAA,EAA6BC,CAAAA,MAAOA,IAAIF,UAAU;IAErE,OAAO;QACLN;QACAS,YAAY;YACVC,MAAM;YACN,mDAAmD;YACnD,qEAAqE;YACrE,2EAA2E;YAC3E,0DAA0D;YAC1DC,gBAAgBC,sCAAAA;QAClB;QACAF,MAAMG,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,OAAO;YAC9B,SAAS;YACT,4EAA4E;YAC5E,4FAA4F;YAC5FhB,KAAKA;YACL,GAAGD,KAAK;YACR,GAAIQ,cAAcJ,cAAc;QAClC,IACA;YAAEc,aAAa;QAAM;QAEvBL,gBAAgBM,IAAAA,+BAAAA,EAAmBnB,MAAMa,cAAc,EAAE;YACvDK,aAAaJ,sCAAAA;YACbM,cAAc;gBACZC,SAASnB;gBACToB,eAAe;YACjB;QACF;IACF;AACF"}

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/useAccordionPanelStyles.styles.js

@@ -0,0 +1,48 @@
+"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, {
+    accordionPanelClassNames: function() {
+        return accordionPanelClassNames;
+    },
+    useAccordionPanelStyles_unstable: function() {
+        return useAccordionPanelStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const accordionPanelClassNames = {
+    root: 'fui-AccordionPanel'
+};
+/**
+ * Styles for the root slot
+ */ const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    root: {
+        jrapky: 0,
+        Frg6f3: 0,
+        t21cq0: 0,
+        B6of3ja: 0,
+        B74szlk: "f1axvtxu"
+    }
+}, {
+    d: [
+        [
+            ".f1axvtxu{margin:0 var(--spacingHorizontalM);}",
+            {
+                p: -1
+            }
+        ]
+    ]
+});
+const useAccordionPanelStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    state.root.className = (0, _react.mergeClasses)(accordionPanelClassNames.root, styles.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-accordion/lib-commonjs/components/AccordionPanel/useAccordionPanelStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useAccordionPanelStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const accordionPanelClassNames = {\n    root: 'fui-AccordionPanel'\n};\n/**\n * Styles for the root slot\n */ const useStyles = makeStyles({\n    root: {\n        margin: `0 ${tokens.spacingHorizontalM}`\n    }\n});\n/** Applies style classnames to slots */ export const useAccordionPanelStyles_unstable = (state)=>{\n    'use no memo';\n    const styles = useStyles();\n    state.root.className = mergeClasses(accordionPanelClassNames.root, styles.root, state.root.className);\n    return state;\n};\n"],"names":["accordionPanelClassNames","useAccordionPanelStyles_unstable","root","useStyles","__styles","jrapky","Frg6f3","t21cq0","B6of3ja","B74szlk","d","p","state","styles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,wBAAwB;eAAxBA;;IAUyCC,gCAAgC;eAAhCA;;;uBAZb;AAElC,MAAMD,2BAA2B;IACpCE,MAAM;AACV;AACA;;CAEA,GAAI,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAF,MAAA;QAAAG,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,SAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;YAAA;YAAA;gBAAAC,GAAA,CAAA;YAAA;SAAA;KAAA;AAAA;AAK0B,MAAMV,mCAAoCW,CAAAA;IACtF;IACA,MAAMC,SAASV;IACfS,MAAMV,IAAI,CAACY,SAAS,GAAGC,IAAAA,mBAAY,EAACf,yBAAyBE,IAAI,EAAEW,OAAOX,IAAI,EAAEU,MAAMV,IAAI,CAACY,SAAS;IACpG,OAAOF;AACX"}

node_modules/@fluentui/react-accordion/lib-commonjs/contexts/accordion.js

@@ -0,0 +1,30 @@
+"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, {
+    AccordionProvider: function() {
+        return AccordionProvider;
+    },
+    useAccordionContext_unstable: function() {
+        return useAccordionContext_unstable;
+    }
+});
+const _reactcontextselector = require("@fluentui/react-context-selector");
+const AccordionContext = (0, _reactcontextselector.createContext)(undefined);
+const accordionContextDefaultValue = {
+    openItems: [],
+    collapsible: false,
+    multiple: false,
+    navigation: undefined,
+    requestToggle () {
+    /* noop */ }
+};
+const { Provider: AccordionProvider } = AccordionContext;
+const useAccordionContext_unstable = (selector)=>(0, _reactcontextselector.useContextSelector)(AccordionContext, (ctx = accordionContextDefaultValue)=>selector(ctx));

node_modules/@fluentui/react-accordion/lib-commonjs/contexts/accordion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/accordion.ts"],"sourcesContent":["import { createContext, ContextSelector, useContextSelector } from '@fluentui/react-context-selector';\nimport type { Context } from '@fluentui/react-context-selector';\nimport { AccordionItemValue } from '../AccordionItem';\nimport { AccordionToggleData, AccordionToggleEvent } from '../Accordion';\n\nexport type AccordionRequestToggleData<Value = AccordionItemValue> = { event: AccordionToggleEvent } & Pick<\n  AccordionToggleData<Value>,\n  'value'\n>;\n\nexport type AccordionContextValue<Value = AccordionItemValue> = {\n  /**\n   * The list of opened panels by index\n   */\n  openItems: AccordionItemValue[];\n  /**\n   * Callback used by AccordionItem to request a change on it's own opened state\n   * Should be used to toggle AccordionItem\n   */\n  requestToggle: (data: AccordionRequestToggleData<Value>) => void;\n  collapsible: boolean;\n  multiple: boolean;\n  navigation: 'linear' | 'circular' | undefined;\n};\n\nconst AccordionContext = createContext<AccordionContextValue | undefined>(undefined) as Context<AccordionContextValue>;\n\nconst accordionContextDefaultValue: AccordionContextValue = {\n  openItems: [],\n  collapsible: false,\n  multiple: false,\n  navigation: undefined,\n  requestToggle() {\n    /* noop */\n  },\n};\n\nexport const { Provider: AccordionProvider } = AccordionContext;\nexport const useAccordionContext_unstable = <T>(selector: ContextSelector<AccordionContextValue, T>): T =>\n  useContextSelector(AccordionContext, (ctx = accordionContextDefaultValue) => selector(ctx));\n"],"names":["AccordionProvider","useAccordionContext_unstable","AccordionContext","createContext","undefined","accordionContextDefaultValue","openItems","collapsible","multiple","navigation","requestToggle","Provider","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAqCyBA,iBAAiB;eAAjBA;;IACZC,4BAAAA;eAAAA;;;sCAtCsD;AAyBnE,MAAMC,mBAAmBC,IAAAA,mCAAAA,EAAiDC;AAE1E,MAAMC,+BAAsD;IAC1DC,WAAW,EAAE;IACbC,aAAa;IACbC,UAAU;IACVC,YAAYL;IACZM;IACE,QAAQ,GACV;AACF;AAEO,MAAM,EAAEC,UAAUX,iBAAiB,EAAE,GAAGE;AACxC,MAAMD,+BAA+B,CAAIW,WAC9CC,IAAAA,wCAAAA,EAAmBX,kBAAkB,CAACY,MAAMT,4BAA4B,GAAKO,SAASE"}

node_modules/@fluentui/react-accordion/lib-commonjs/contexts/accordionHeader.js

@@ -0,0 +1,32 @@
+"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, {
+    AccordionHeaderProvider: function() {
+        return AccordionHeaderProvider;
+    },
+    useAccordionHeaderContext_unstable: function() {
+        return useAccordionHeaderContext_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const AccordionHeaderContext = /*#__PURE__*/ _react.createContext(undefined);
+const accordionHeaderContextDefaultValue = {
+    open: false,
+    disabled: false,
+    size: 'medium',
+    expandIconPosition: 'start'
+};
+const { Provider: AccordionHeaderProvider } = AccordionHeaderContext;
+const useAccordionHeaderContext_unstable = ()=>{
+    var _React_useContext;
+    return (_React_useContext = _react.useContext(AccordionHeaderContext)) !== null && _React_useContext !== void 0 ? _React_useContext : accordionHeaderContextDefaultValue;
+};

node_modules/@fluentui/react-accordion/lib-commonjs/contexts/accordionHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/accordionHeader.ts"],"sourcesContent":["import * as React from 'react';\nimport type {\n  AccordionHeaderExpandIconPosition,\n  AccordionHeaderSize,\n} from '../components/AccordionHeader/AccordionHeader.types';\n\nexport type AccordionHeaderContextValue = {\n  disabled: boolean;\n  open: boolean;\n  expandIconPosition: AccordionHeaderExpandIconPosition;\n  size: AccordionHeaderSize;\n};\n\nconst AccordionHeaderContext = React.createContext<AccordionHeaderContextValue | undefined>(\n  undefined,\n) as React.Context<AccordionHeaderContextValue>;\n\nconst accordionHeaderContextDefaultValue = {\n  open: false,\n  disabled: false,\n  size: 'medium',\n  expandIconPosition: 'start',\n};\n\nexport const { Provider: AccordionHeaderProvider } = AccordionHeaderContext;\n\nexport const useAccordionHeaderContext_unstable = () =>\n  React.useContext(AccordionHeaderContext) ?? accordionHeaderContextDefaultValue;\n"],"names":["AccordionHeaderProvider","useAccordionHeaderContext_unstable","AccordionHeaderContext","React","createContext","undefined","accordionHeaderContextDefaultValue","open","disabled","size","expandIconPosition","Provider","useContext"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAwByBA,uBAAuB;eAAvBA;;IAEZC,kCAAAA;eAAAA;;;;iEA1BU;AAavB,MAAMC,uCAAyBC,OAAMC,aAAa,CAChDC;AAGF,MAAMC,qCAAqC;IACzCC,MAAM;IACNC,UAAU;IACVC,MAAM;IACNC,oBAAoB;AACtB;AAEO,MAAM,EAAEC,UAAUX,uBAAuB,EAAE,GAAGE;AAE9C,MAAMD,qCAAqC;QAChDE;WAAAA,CAAAA,oBAAAA,OAAMS,UAAU,CAACV,uBAAAA,MAAAA,QAAjBC,sBAAAA,KAAAA,IAAAA,oBAA4CG;AAAiC"}

node_modules/@fluentui/react-accordion/lib-commonjs/contexts/accordionItem.js

@@ -0,0 +1,33 @@
+"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, {
+    AccordionItemProvider: function() {
+        return AccordionItemProvider;
+    },
+    useAccordionItemContext_unstable: function() {
+        return useAccordionItemContext_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const AccordionItemContext = /*#__PURE__*/ _react.createContext(undefined);
+const accordionItemContextDefaultValue = {
+    open: false,
+    disabled: false,
+    value: undefined,
+    onHeaderClick () {
+    /* noop */ }
+};
+const { Provider: AccordionItemProvider } = AccordionItemContext;
+const useAccordionItemContext_unstable = ()=>{
+    var _React_useContext;
+    return (_React_useContext = _react.useContext(AccordionItemContext)) !== null && _React_useContext !== void 0 ? _React_useContext : accordionItemContextDefaultValue;
+};

node_modules/@fluentui/react-accordion/lib-commonjs/contexts/accordionItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/accordionItem.ts"],"sourcesContent":["import * as React from 'react';\nimport { AccordionItemValue } from '../AccordionItem';\nimport { AccordionToggleEvent } from '../Accordion';\n\nexport type AccordionItemContextValue<Value = AccordionItemValue> = {\n  open: boolean;\n  disabled: boolean;\n  value: Value;\n  /**\n   * @deprecated - use `requestToggle` from AccordionContent instead\n   */\n  onHeaderClick(event: AccordionToggleEvent): void;\n};\n\nconst AccordionItemContext = React.createContext<AccordionItemContextValue<unknown> | undefined>(\n  undefined,\n) as React.Context<AccordionItemContextValue<unknown>>;\n\nconst accordionItemContextDefaultValue: AccordionItemContextValue<unknown> = {\n  open: false,\n  disabled: false,\n  value: undefined,\n  onHeaderClick() {\n    /* noop */\n  },\n};\n\nexport const { Provider: AccordionItemProvider } = AccordionItemContext;\n\nexport const useAccordionItemContext_unstable = () => {\n  return React.useContext(AccordionItemContext) ?? accordionItemContextDefaultValue;\n};\n"],"names":["AccordionItemProvider","useAccordionItemContext_unstable","AccordionItemContext","React","createContext","undefined","accordionItemContextDefaultValue","open","disabled","value","onHeaderClick","Provider","useContext"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA2ByBA,qBAAqB;eAArBA;;IAEZC,gCAAAA;eAAAA;;;;iEA7BU;AAcvB,MAAMC,qCAAuBC,OAAMC,aAAa,CAC9CC;AAGF,MAAMC,mCAAuE;IAC3EC,MAAM;IACNC,UAAU;IACVC,OAAOJ;IACPK;IACE,QAAQ,GACV;AACF;AAEO,MAAM,EAAEC,UAAUX,qBAAqB,EAAE,GAAGE;AAE5C,MAAMD,mCAAmC;QACvCE;IAAP,OAAOA,CAAAA,oBAAAA,OAAMS,UAAU,CAACV,qBAAAA,MAAAA,QAAjBC,sBAAAA,KAAAA,IAAAA,oBAA0CG;AACnD"}

node_modules/@fluentui/react-accordion/lib-commonjs/index.js

@@ -0,0 +1,106 @@
+"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, {
+    Accordion: function() {
+        return _Accordion.Accordion;
+    },
+    AccordionHeader: function() {
+        return _AccordionHeader.AccordionHeader;
+    },
+    AccordionHeaderProvider: function() {
+        return _accordionHeader.AccordionHeaderProvider;
+    },
+    AccordionItem: function() {
+        return _AccordionItem.AccordionItem;
+    },
+    AccordionItemProvider: function() {
+        return _accordionItem.AccordionItemProvider;
+    },
+    AccordionPanel: function() {
+        return _AccordionPanel.AccordionPanel;
+    },
+    AccordionProvider: function() {
+        return _accordion.AccordionProvider;
+    },
+    accordionClassNames: function() {
+        return _Accordion.accordionClassNames;
+    },
+    accordionHeaderClassNames: function() {
+        return _AccordionHeader.accordionHeaderClassNames;
+    },
+    accordionItemClassNames: function() {
+        return _AccordionItem.accordionItemClassNames;
+    },
+    accordionPanelClassNames: function() {
+        return _AccordionPanel.accordionPanelClassNames;
+    },
+    renderAccordionHeader_unstable: function() {
+        return _AccordionHeader.renderAccordionHeader_unstable;
+    },
+    renderAccordionItem_unstable: function() {
+        return _AccordionItem.renderAccordionItem_unstable;
+    },
+    renderAccordionPanel_unstable: function() {
+        return _AccordionPanel.renderAccordionPanel_unstable;
+    },
+    renderAccordion_unstable: function() {
+        return _Accordion.renderAccordion_unstable;
+    },
+    useAccordionContextValues_unstable: function() {
+        return _Accordion.useAccordionContextValues_unstable;
+    },
+    useAccordionContext_unstable: function() {
+        return _accordion.useAccordionContext_unstable;
+    },
+    useAccordionHeaderContextValues_unstable: function() {
+        return _AccordionHeader.useAccordionHeaderContextValues_unstable;
+    },
+    useAccordionHeaderContext_unstable: function() {
+        return _accordionHeader.useAccordionHeaderContext_unstable;
+    },
+    useAccordionHeaderStyles_unstable: function() {
+        return _AccordionHeader.useAccordionHeaderStyles_unstable;
+    },
+    useAccordionHeader_unstable: function() {
+        return _AccordionHeader.useAccordionHeader_unstable;
+    },
+    useAccordionItemContextValues_unstable: function() {
+        return _AccordionItem.useAccordionItemContextValues_unstable;
+    },
+    useAccordionItemContext_unstable: function() {
+        return _accordionItem.useAccordionItemContext_unstable;
+    },
+    useAccordionItemStyles_unstable: function() {
+        return _AccordionItem.useAccordionItemStyles_unstable;
+    },
+    useAccordionItem_unstable: function() {
+        return _AccordionItem.useAccordionItem_unstable;
+    },
+    useAccordionPanelStyles_unstable: function() {
+        return _AccordionPanel.useAccordionPanelStyles_unstable;
+    },
+    useAccordionPanel_unstable: function() {
+        return _AccordionPanel.useAccordionPanel_unstable;
+    },
+    useAccordionStyles_unstable: function() {
+        return _Accordion.useAccordionStyles_unstable;
+    },
+    useAccordion_unstable: function() {
+        return _Accordion.useAccordion_unstable;
+    }
+});
+const _Accordion = require("./Accordion");
+const _AccordionItem = require("./AccordionItem");
+const _AccordionHeader = require("./AccordionHeader");
+const _AccordionPanel = require("./AccordionPanel");
+const _accordion = require("./contexts/accordion");
+const _accordionItem = require("./contexts/accordionItem");
+const _accordionHeader = require("./contexts/accordionHeader");

node_modules/@fluentui/react-accordion/lib-commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  Accordion,\n  accordionClassNames,\n  renderAccordion_unstable,\n  useAccordionContextValues_unstable,\n  useAccordionStyles_unstable,\n  useAccordion_unstable,\n} from './Accordion';\nexport type {\n  AccordionContextValues,\n  AccordionIndex,\n  AccordionProps,\n  AccordionSlots,\n  AccordionState,\n  AccordionToggleData,\n  AccordionToggleEvent,\n  AccordionToggleEventHandler,\n} from './Accordion';\nexport {\n  AccordionItem,\n  accordionItemClassNames,\n  renderAccordionItem_unstable,\n  useAccordionItemContextValues_unstable,\n  useAccordionItemStyles_unstable,\n  useAccordionItem_unstable,\n} from './AccordionItem';\nexport type {\n  AccordionItemContextValues,\n  AccordionItemProps,\n  AccordionItemSlots,\n  AccordionItemState,\n  AccordionItemValue,\n} from './AccordionItem';\nexport {\n  AccordionHeader,\n  accordionHeaderClassNames,\n  renderAccordionHeader_unstable,\n  useAccordionHeaderContextValues_unstable,\n  useAccordionHeaderStyles_unstable,\n  useAccordionHeader_unstable,\n} from './AccordionHeader';\nexport type {\n  AccordionHeaderContextValues,\n  AccordionHeaderExpandIconPosition,\n  AccordionHeaderProps,\n  AccordionHeaderSize,\n  AccordionHeaderSlots,\n  AccordionHeaderState,\n} from './AccordionHeader';\nexport {\n  AccordionPanel,\n  accordionPanelClassNames,\n  renderAccordionPanel_unstable,\n  useAccordionPanelStyles_unstable,\n  useAccordionPanel_unstable,\n} from './AccordionPanel';\nexport type { AccordionPanelProps, AccordionPanelSlots, AccordionPanelState } from './AccordionPanel';\n\nexport { AccordionProvider, useAccordionContext_unstable } from './contexts/accordion';\n\nexport type { AccordionContextValue } from './contexts/accordion';\n\nexport { AccordionItemProvider, useAccordionItemContext_unstable } from './contexts/accordionItem';\n\nexport type { AccordionItemContextValue } from './contexts/accordionItem';\n\nexport { AccordionHeaderProvider, useAccordionHeaderContext_unstable } from './contexts/accordionHeader';\n\nexport type { AccordionHeaderContextValue } from './contexts/accordionHeader';\n"],"names":["Accordion","AccordionHeader","AccordionHeaderProvider","AccordionItem","AccordionItemProvider","AccordionPanel","AccordionProvider","accordionClassNames","accordionHeaderClassNames","accordionItemClassNames","accordionPanelClassNames","renderAccordionHeader_unstable","renderAccordionItem_unstable","renderAccordionPanel_unstable","renderAccordion_unstable","useAccordionContextValues_unstable","useAccordionContext_unstable","useAccordionHeaderContextValues_unstable","useAccordionHeaderContext_unstable","useAccordionHeaderStyles_unstable","useAccordionHeader_unstable","useAccordionItemContextValues_unstable","useAccordionItemContext_unstable","useAccordionItemStyles_unstable","useAccordionItem_unstable","useAccordionPanelStyles_unstable","useAccordionPanel_unstable","useAccordionStyles_unstable","useAccordion_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACEA,SAAS;eAATA,oBAAS;;IAiCTC,eAAe;eAAfA,gCAAe;;IAgCRC,uBAAuB;eAAvBA,wCAAuB;;IA/C9BC,aAAa;eAAbA,4BAAa;;IA2CNC,qBAAqB;eAArBA,oCAAqB;;IAZ5BC,cAAc;eAAdA,8BAAc;;IAQPC,iBAAiB;eAAjBA,4BAAiB;;IAxDxBC,mBAAmB;eAAnBA,8BAAmB;;IAiCnBC,yBAAyB;eAAzBA,0CAAyB;;IAfzBC,uBAAuB;eAAvBA,sCAAuB;;IA+BvBC,wBAAwB;eAAxBA,wCAAwB;;IAfxBC,8BAA8B;eAA9BA,+CAA8B;;IAf9BC,4BAA4B;eAA5BA,2CAA4B;;IA+B5BC,6BAA6B;eAA7BA,6CAA6B;;IAjD7BC,wBAAwB;eAAxBA,mCAAwB;;IACxBC,kCAAkC;eAAlCA,6CAAkC;;IAsDRC,4BAA4B;eAA5BA,uCAA4B;;IArBtDC,wCAAwC;eAAxCA,yDAAwC;;IA6BRC,kCAAkC;eAAlCA,mDAAkC;;IA5BlEC,iCAAiC;eAAjCA,kDAAiC;;IACjCC,2BAA2B;eAA3BA,4CAA2B;;IAjB3BC,sCAAsC;eAAtCA,qDAAsC;;IAwCRC,gCAAgC;eAAhCA,+CAAgC;;IAvC9DC,+BAA+B;eAA/BA,8CAA+B;;IAC/BC,yBAAyB;eAAzBA,wCAAyB;;IA6BzBC,gCAAgC;eAAhCA,gDAAgC;;IAChCC,0BAA0B;eAA1BA,0CAA0B;;IAjD1BC,2BAA2B;eAA3BA,sCAA2B;;IAC3BC,qBAAqB;eAArBA,gCAAqB;;;2BAChB;+BAkBA;iCAeA;gCAeA;2BAGyD;+BAIQ;iCAII"}