@fluentui/react-utilities 9.18.11 → 9.18.12

package/lib-commonjs/index.js

@@ -9,11 +9,53 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    slot: function() {
-        return _index.slot;
+    IdPrefixProvider: function() {
+        return _index1.IdPrefixProvider;
     },
-    isSlot: function() {
-        return _index.isSlot;
+    SLOT_ELEMENT_TYPE_SYMBOL: function() {
+        return _index.SLOT_ELEMENT_TYPE_SYMBOL;
+    },
+    SLOT_RENDER_FUNCTION_SYMBOL: function() {
+        return _index.SLOT_RENDER_FUNCTION_SYMBOL;
+    },
+    SSRProvider: function() {
+        return _index2.SSRProvider;
+    },
+    applyTriggerPropsToChildren: function() {
+        return _index4.applyTriggerPropsToChildren;
+    },
+    assertSlots: function() {
+        return _index.assertSlots;
+    },
+    canUseDOM: function() {
+        return _index2.canUseDOM;
+    },
+    clamp: function() {
+        return _index3.clamp;
+    },
+    createPriorityQueue: function() {
+        return _index3.createPriorityQueue;
+    },
+    elementContains: function() {
+        return _index7.elementContains;
+    },
+    getEventClientCoords: function() {
+        return _index5.getEventClientCoords;
+    },
+    getIntrinsicElementProps: function() {
+        return _index.getIntrinsicElementProps;
+    },
+    getNativeElementProps: function() {
+        return _index3.getNativeElementProps;
+    },
+    getParent: function() {
+        return _index7.getParent;
+    },
+    getPartitionedNativeProps: function() {
+        return _index3.getPartitionedNativeProps;
+    },
+    getRTLSafeKey: function() {
+        return _index3.getRTLSafeKey;
     },
     getSlots: function() {
         return _index.getSlots;
@@ -21,30 +63,48 @@ _export(exports, {
     getSlotsNext: function() {
         return _index.getSlotsNext;
     },
-    assertSlots: function() {
-        return _index.assertSlots;
+    getTriggerChild: function() {
+        return _index4.getTriggerChild;
     },
-    resolveShorthand: function() {
-        return _index.resolveShorthand;
+    isFluentTrigger: function() {
+        return _index4.isFluentTrigger;
+    },
+    isHTMLElement: function() {
+        return _index3.isHTMLElement;
+    },
+    isInteractiveHTMLElement: function() {
+        return _index3.isInteractiveHTMLElement;
+    },
+    isMouseEvent: function() {
+        return _index5.isMouseEvent;
     },
     isResolvedShorthand: function() {
         return _index.isResolvedShorthand;
     },
-    getIntrinsicElementProps: function() {
-        return _index.getIntrinsicElementProps;
+    isSlot: function() {
+        return _index.isSlot;
     },
-    SLOT_ELEMENT_TYPE_SYMBOL: function() {
-        return _index.SLOT_ELEMENT_TYPE_SYMBOL;
+    isTouchEvent: function() {
+        return _index5.isTouchEvent;
     },
-    SLOT_RENDER_FUNCTION_SYMBOL: function() {
-        return _index.SLOT_RENDER_FUNCTION_SYMBOL;
+    mergeCallbacks: function() {
+        return _index3.mergeCallbacks;
     },
-    IdPrefixProvider: function() {
-        return _index1.IdPrefixProvider;
+    omit: function() {
+        return _index3.omit;
     },
     resetIdsForTests: function() {
         return _index1.resetIdsForTests;
     },
+    resolveShorthand: function() {
+        return _index.resolveShorthand;
+    },
+    setVirtualParent: function() {
+        return _index7.setVirtualParent;
+    },
+    slot: function() {
+        return _index.slot;
+    },
     useAnimationFrame: function() {
         return _index1.useAnimationFrame;
     },
@@ -63,6 +123,9 @@ _export(exports, {
     useId: function() {
         return _index1.useId;
     },
+    useIsSSR: function() {
+        return _index2.useIsSSR;
+    },
     useIsomorphicLayoutEffect: function() {
         return _index1.useIsomorphicLayoutEffect;
     },
@@ -81,74 +144,11 @@ _export(exports, {
     useScrollbarWidth: function() {
         return _index1.useScrollbarWidth;
     },
-    useTimeout: function() {
-        return _index1.useTimeout;
-    },
-    canUseDOM: function() {
-        return _index2.canUseDOM;
-    },
-    useIsSSR: function() {
-        return _index2.useIsSSR;
-    },
-    SSRProvider: function() {
-        return _index2.SSRProvider;
-    },
-    clamp: function() {
-        return _index3.clamp;
-    },
-    getNativeElementProps: function() {
-        return _index3.getNativeElementProps;
-    },
-    getPartitionedNativeProps: function() {
-        return _index3.getPartitionedNativeProps;
-    },
-    getRTLSafeKey: function() {
-        return _index3.getRTLSafeKey;
-    },
-    mergeCallbacks: function() {
-        return _index3.mergeCallbacks;
-    },
-    isHTMLElement: function() {
-        return _index3.isHTMLElement;
-    },
-    isInteractiveHTMLElement: function() {
-        return _index3.isInteractiveHTMLElement;
-    },
-    omit: function() {
-        return _index3.omit;
-    },
-    createPriorityQueue: function() {
-        return _index3.createPriorityQueue;
-    },
-    applyTriggerPropsToChildren: function() {
-        return _index4.applyTriggerPropsToChildren;
-    },
-    getTriggerChild: function() {
-        return _index4.getTriggerChild;
-    },
-    isFluentTrigger: function() {
-        return _index4.isFluentTrigger;
-    },
-    isTouchEvent: function() {
-        return _index5.isTouchEvent;
-    },
-    isMouseEvent: function() {
-        return _index5.isMouseEvent;
-    },
-    getEventClientCoords: function() {
-        return _index5.getEventClientCoords;
-    },
     useSelection: function() {
         return _index6.useSelection;
     },
-    elementContains: function() {
-        return _index7.elementContains;
-    },
-    setVirtualParent: function() {
-        return _index7.setVirtualParent;
-    },
-    getParent: function() {
-        return _index7.getParent;
+    useTimeout: function() {
+        return _index1.useTimeout;
     }
 });
 const _index = require("./compose/index");

package/lib-commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export { slot, isSlot, // eslint-disable-next-line deprecation/deprecation\ngetSlots, // eslint-disable-next-line deprecation/deprecation\ngetSlotsNext, assertSlots, // eslint-disable-next-line deprecation/deprecation\nresolveShorthand, isResolvedShorthand, getIntrinsicElementProps, SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './compose/index';\nexport { IdPrefixProvider, resetIdsForTests, useAnimationFrame, useControllableState, useEventCallback, useFirstMount, useForceUpdate, useId, useIsomorphicLayoutEffect, useMergedRefs, useOnClickOutside, useOnScrollOutside, usePrevious, useScrollbarWidth, useTimeout } from './hooks/index';\nexport { canUseDOM, useIsSSR, SSRProvider } from './ssr/index';\nexport { clamp, // eslint-disable-next-line deprecation/deprecation\ngetNativeElementProps, getPartitionedNativeProps, getRTLSafeKey, mergeCallbacks, isHTMLElement, isInteractiveHTMLElement, omit, createPriorityQueue } from './utils/index';\nexport { applyTriggerPropsToChildren, getTriggerChild, isFluentTrigger } from './trigger/index';\nexport { isTouchEvent, isMouseEvent, getEventClientCoords } from './events/index';\nexport { useSelection } from './selection/index';\nexport { elementContains, setVirtualParent, getParent } from './virtualParent/index';\n"],"names":["slot","isSlot","getSlots","getSlotsNext","assertSlots","resolveShorthand","isResolvedShorthand","getIntrinsicElementProps","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","IdPrefixProvider","resetIdsForTests","useAnimationFrame","useControllableState","useEventCallback","useFirstMount","useForceUpdate","useId","useIsomorphicLayoutEffect","useMergedRefs","useOnClickOutside","useOnScrollOutside","usePrevious","useScrollbarWidth","useTimeout","canUseDOM","useIsSSR","SSRProvider","clamp","getNativeElementProps","getPartitionedNativeProps","getRTLSafeKey","mergeCallbacks","isHTMLElement","isInteractiveHTMLElement","omit","createPriorityQueue","applyTriggerPropsToChildren","getTriggerChild","isFluentTrigger","isTouchEvent","isMouseEvent","getEventClientCoords","useSelection","elementContains","setVirtualParent","getParent"],"mappings":";;;;;;;;;;;IAASA,IAAI;eAAJA,WAAI;;IAAEC,MAAM;eAANA,aAAM;;IACrBC,QAAQ;eAARA,eAAQ;;IACRC,YAAY;eAAZA,mBAAY;;IAAEC,WAAW;eAAXA,kBAAW;;IACzBC,gBAAgB;eAAhBA,uBAAgB;;IAAEC,mBAAmB;eAAnBA,0BAAmB;;IAAEC,wBAAwB;eAAxBA,+BAAwB;;IAAEC,wBAAwB;eAAxBA,+BAAwB;;IAAEC,2BAA2B;eAA3BA,kCAA2B;;IAC7GC,gBAAgB;eAAhBA,wBAAgB;;IAAEC,gBAAgB;eAAhBA,wBAAgB;;IAAEC,iBAAiB;eAAjBA,yBAAiB;;IAAEC,oBAAoB;eAApBA,4BAAoB;;IAAEC,gBAAgB;eAAhBA,wBAAgB;;IAAEC,aAAa;eAAbA,qBAAa;;IAAEC,cAAc;eAAdA,sBAAc;;IAAEC,KAAK;eAALA,aAAK;;IAAEC,yBAAyB;eAAzBA,iCAAyB;;IAAEC,aAAa;eAAbA,qBAAa;;IAAEC,iBAAiB;eAAjBA,yBAAiB;;IAAEC,kBAAkB;eAAlBA,0BAAkB;;IAAEC,WAAW;eAAXA,mBAAW;;IAAEC,iBAAiB;eAAjBA,yBAAiB;;IAAEC,UAAU;eAAVA,kBAAU;;IAChQC,SAAS;eAATA,iBAAS;;IAAEC,QAAQ;eAARA,gBAAQ;;IAAEC,WAAW;eAAXA,mBAAW;;IAChCC,KAAK;eAALA,aAAK;;IACdC,qBAAqB;eAArBA,6BAAqB;;IAAEC,yBAAyB;eAAzBA,iCAAyB;;IAAEC,aAAa;eAAbA,qBAAa;;IAAEC,cAAc;eAAdA,sBAAc;;IAAEC,aAAa;eAAbA,qBAAa;;IAAEC,wBAAwB;eAAxBA,gCAAwB;;IAAEC,IAAI;eAAJA,YAAI;;IAAEC,mBAAmB;eAAnBA,2BAAmB;;IAC1IC,2BAA2B;eAA3BA,mCAA2B;;IAAEC,eAAe;eAAfA,uBAAe;;IAAEC,eAAe;eAAfA,uBAAe;;IAC7DC,YAAY;eAAZA,oBAAY;;IAAEC,YAAY;eAAZA,oBAAY;;IAAEC,oBAAoB;eAApBA,4BAAoB;;IAChDC,YAAY;eAAZA,oBAAY;;IACZC,eAAe;eAAfA,uBAAe;;IAAEC,gBAAgB;eAAhBA,wBAAgB;;IAAEC,SAAS;eAATA,iBAAS;;;uBARyE;wBACmJ;wBAChO;wBAE0G;wBAC7E;wBACb;wBACpC;wBACgC"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  slot,\n  isSlot,\n  // eslint-disable-next-line deprecation/deprecation\n  getSlots,\n  // eslint-disable-next-line deprecation/deprecation\n  getSlotsNext,\n  assertSlots,\n  // eslint-disable-next-line deprecation/deprecation\n  resolveShorthand,\n  isResolvedShorthand,\n  getIntrinsicElementProps,\n  SLOT_ELEMENT_TYPE_SYMBOL,\n  SLOT_RENDER_FUNCTION_SYMBOL,\n} from './compose/index';\nexport type {\n  ExtractSlotProps,\n  ComponentProps,\n  ComponentState,\n  ForwardRefComponent,\n  // eslint-disable-next-line deprecation/deprecation\n  ResolveShorthandFunction,\n  // eslint-disable-next-line deprecation/deprecation\n  ResolveShorthandOptions,\n  Slot,\n  // eslint-disable-next-line deprecation/deprecation\n  Slots,\n  SlotClassNames,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  SlotShorthandValue,\n  UnknownSlotProps,\n  SlotComponentType,\n  SlotOptions,\n  InferredElementRefType,\n  EventData,\n  EventHandler,\n} from './compose/index';\n\nexport {\n  IdPrefixProvider,\n  resetIdsForTests,\n  useAnimationFrame,\n  useControllableState,\n  useEventCallback,\n  useFirstMount,\n  useForceUpdate,\n  useId,\n  useIsomorphicLayoutEffect,\n  useMergedRefs,\n  useOnClickOutside,\n  useOnScrollOutside,\n  usePrevious,\n  useScrollbarWidth,\n  useTimeout,\n} from './hooks/index';\nexport type { RefObjectFunction, UseControllableStateOptions, UseOnClickOrScrollOutsideOptions } from './hooks/index';\n\nexport { canUseDOM, useIsSSR, SSRProvider } from './ssr/index';\n\nexport {\n  clamp,\n  // eslint-disable-next-line deprecation/deprecation\n  getNativeElementProps,\n  getPartitionedNativeProps,\n  getRTLSafeKey,\n  mergeCallbacks,\n  isHTMLElement,\n  isInteractiveHTMLElement,\n  omit,\n  createPriorityQueue,\n} from './utils/index';\n\nexport type { DistributiveOmit, UnionToIntersection } from './utils/types';\n\nexport type { PriorityQueue } from './utils/priorityQueue';\n\nexport { applyTriggerPropsToChildren, getTriggerChild, isFluentTrigger } from './trigger/index';\n\nexport type { FluentTriggerComponent, TriggerProps } from './trigger/index';\n\n/**\n * Event utils\n */\nexport type { NativeTouchOrMouseEvent, ReactTouchOrMouseEvent, TouchOrMouseEvent } from './events/index';\nexport { isTouchEvent, isMouseEvent, getEventClientCoords } from './events/index';\n\nexport type {\n  SelectionMode,\n  OnSelectionChangeCallback,\n  OnSelectionChangeData,\n  SelectionItemId,\n  SelectionHookParams,\n  SelectionMethods,\n} from './selection/index';\nexport { useSelection } from './selection/index';\n\nexport { elementContains, setVirtualParent, getParent } from './virtualParent/index';\n"],"names":["IdPrefixProvider","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","SSRProvider","applyTriggerPropsToChildren","assertSlots","canUseDOM","clamp","createPriorityQueue","elementContains","getEventClientCoords","getIntrinsicElementProps","getNativeElementProps","getParent","getPartitionedNativeProps","getRTLSafeKey","getSlots","getSlotsNext","getTriggerChild","isFluentTrigger","isHTMLElement","isInteractiveHTMLElement","isMouseEvent","isResolvedShorthand","isSlot","isTouchEvent","mergeCallbacks","omit","resetIdsForTests","resolveShorthand","setVirtualParent","slot","useAnimationFrame","useControllableState","useEventCallback","useFirstMount","useForceUpdate","useId","useIsSSR","useIsomorphicLayoutEffect","useMergedRefs","useOnClickOutside","useOnScrollOutside","usePrevious","useScrollbarWidth","useSelection","useTimeout"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAwCEA,gBAAgB;eAAhBA,wBAAgB;;IA5BhBC,wBAAwB;eAAxBA,+BAAwB;;IACxBC,2BAA2B;eAA3BA,kCAA2B;;IA6CCC,WAAW;eAAXA,mBAAW;;IAmBhCC,2BAA2B;eAA3BA,mCAA2B;;IAtElCC,WAAW;eAAXA,kBAAW;;IAmDJC,SAAS;eAATA,iBAAS;;IAGhBC,KAAK;eAALA,aAAK;;IASLC,mBAAmB;eAAnBA,2BAAmB;;IA2BZC,eAAe;eAAfA,uBAAe;;IAZaC,oBAAoB;eAApBA,4BAAoB;;IA1EvDC,wBAAwB;eAAxBA,+BAAwB;;IAoDxBC,qBAAqB;eAArBA,6BAAqB;;IAkCqBC,SAAS;eAATA,iBAAS;;IAjCnDC,yBAAyB;eAAzBA,iCAAyB;;IACzBC,aAAa;eAAbA,qBAAa;;IA7DbC,QAAQ;eAARA,eAAQ;;IAERC,YAAY;eAAZA,mBAAY;;IAuEwBC,eAAe;eAAfA,uBAAe;;IAAEC,eAAe;eAAfA,uBAAe;;IAVpEC,aAAa;eAAbA,qBAAa;;IACbC,wBAAwB;eAAxBA,gCAAwB;;IAiBHC,YAAY;eAAZA,oBAAY;;IA3EjCC,mBAAmB;eAAnBA,0BAAmB;;IARnBC,MAAM;eAANA,aAAM;;IAmFCC,YAAY;eAAZA,oBAAY;;IAnBnBC,cAAc;eAAdA,sBAAc;;IAGdC,IAAI;eAAJA,YAAI;;IA5BJC,gBAAgB;eAAhBA,wBAAgB;;IAhChBC,gBAAgB;eAAhBA,uBAAgB;;IAwFQC,gBAAgB;eAAhBA,wBAAgB;;IAhGxCC,IAAI;eAAJA,WAAI;;IAyCJC,iBAAiB;eAAjBA,yBAAiB;;IACjBC,oBAAoB;eAApBA,4BAAoB;;IACpBC,gBAAgB;eAAhBA,wBAAgB;;IAChBC,aAAa;eAAbA,qBAAa;;IACbC,cAAc;eAAdA,sBAAc;;IACdC,KAAK;eAALA,aAAK;;IAWaC,QAAQ;eAARA,gBAAQ;;IAV1BC,yBAAyB;eAAzBA,iCAAyB;;IACzBC,aAAa;eAAbA,qBAAa;;IACbC,iBAAiB;eAAjBA,yBAAiB;;IACjBC,kBAAkB;eAAlBA,0BAAkB;;IAClBC,WAAW;eAAXA,mBAAW;;IACXC,iBAAiB;eAAjBA,yBAAiB;;IA0CVC,YAAY;eAAZA,oBAAY;;IAzCnBC,UAAU;eAAVA,kBAAU;;;uBAxCL;wBAyCA;wBAG0C;wBAa1C;wBAMuE;wBAQb;wBAUpC;wBAEgC"}

package/lib-commonjs/selection/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './types';\nexport * from './useSelection';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './types';\nexport * from './useSelection';\n"],"names":[],"rangeMappings":";;;;;;","mappings":";;;;;uBAAc;uBACA"}

package/lib-commonjs/selection/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.js"],"sourcesContent":["import * as React from 'react';\n"],"names":[],"mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type SelectionMode = 'single' | 'multiselect';\n\nexport interface SelectionMethods {\n  toggleItem(event: React.SyntheticEvent, id: SelectionItemId): void;\n  selectItem(event: React.SyntheticEvent, id: SelectionItemId): void;\n  deselectItem(event: React.SyntheticEvent, id: SelectionItemId): void;\n  clearItems(event: React.SyntheticEvent): void;\n  isSelected(id: SelectionItemId): boolean;\n  toggleAllItems(event: React.SyntheticEvent, itemIds: SelectionItemId[]): void;\n}\n\nexport type SelectionItemId = string | number;\n\nexport type OnSelectionChangeCallback = (event: React.SyntheticEvent, selectedItems: Set<SelectionItemId>) => void;\n\nexport type OnSelectionChangeData = {\n  selectedItems: Set<SelectionItemId>;\n};\n\nexport type SelectionHookParams = {\n  selectionMode: SelectionMode;\n  /**\n   * Used in uncontrolled mode to set initial selected items on mount\n   */\n  defaultSelectedItems?: Iterable<SelectionItemId>;\n  /**\n   * Used to control selected items\n   */\n  selectedItems?: Iterable<SelectionItemId>;\n  /**\n   * Called when selection changes\n   */\n  onSelectionChange?(event: React.SyntheticEvent, data: OnSelectionChangeData): void;\n};\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/selection/useSelection.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useSelection.js"],"sourcesContent":["import * as React from 'react';\nimport { useControllableState } from '../hooks/useControllableState';\nimport { createSetFromIterable } from '../utils/createSetFromIterable';\nfunction useSelectionState(params) {\n    const [selected, setSelected] = useControllableState({\n        initialState: new Set(),\n        defaultState: React.useMemo(()=>params.defaultSelectedItems && createSetFromIterable(params.defaultSelectedItems), [\n            params.defaultSelectedItems\n        ]),\n        state: React.useMemo(()=>params.selectedItems && createSetFromIterable(params.selectedItems), [\n            params.selectedItems\n        ])\n    });\n    const changeSelection = (event, nextSelectedItems)=>{\n        var _params_onSelectionChange;\n        (_params_onSelectionChange = params.onSelectionChange) === null || _params_onSelectionChange === void 0 ? void 0 : _params_onSelectionChange.call(params, event, {\n            selectedItems: nextSelectedItems\n        });\n        setSelected(nextSelectedItems);\n    };\n    return [\n        selected,\n        changeSelection\n    ];\n}\nfunction useSingleSelection(params) {\n    const [selected, changeSelection] = useSelectionState(params);\n    const methods = {\n        deselectItem: (event)=>changeSelection(event, new Set()),\n        selectItem: (event, itemId)=>changeSelection(event, new Set([\n                itemId\n            ])),\n        toggleAllItems: ()=>{\n            if (process.env.NODE_ENV !== 'production') {\n                throw new Error('[react-utilities]: `toggleAllItems` should not be used in single selection mode');\n            }\n        },\n        toggleItem: (event, itemId)=>changeSelection(event, new Set([\n                itemId\n            ])),\n        clearItems: (event)=>changeSelection(event, new Set()),\n        isSelected: (itemId)=>{\n            var _selected_has;\n            return (_selected_has = selected.has(itemId)) !== null && _selected_has !== void 0 ? _selected_has : false;\n        }\n    };\n    return [\n        selected,\n        methods\n    ];\n}\nfunction useMultipleSelection(params) {\n    const [selected, changeSelection] = useSelectionState(params);\n    const methods = {\n        toggleItem: (event, itemId)=>{\n            const nextSelectedItems = new Set(selected);\n            if (selected.has(itemId)) {\n                nextSelectedItems.delete(itemId);\n            } else {\n                nextSelectedItems.add(itemId);\n            }\n            changeSelection(event, nextSelectedItems);\n        },\n        selectItem: (event, itemId)=>{\n            const nextSelectedItems = new Set(selected);\n            nextSelectedItems.add(itemId);\n            changeSelection(event, nextSelectedItems);\n        },\n        deselectItem: (event, itemId)=>{\n            const nextSelectedItems = new Set(selected);\n            nextSelectedItems.delete(itemId);\n            changeSelection(event, nextSelectedItems);\n        },\n        clearItems: (event)=>{\n            changeSelection(event, new Set());\n        },\n        isSelected: (itemId)=>selected.has(itemId),\n        toggleAllItems: (event, itemIds)=>{\n            const allItemsSelected = itemIds.every((itemId)=>selected.has(itemId));\n            const nextSelectedItems = new Set(selected);\n            if (allItemsSelected) {\n                nextSelectedItems.clear();\n            } else {\n                itemIds.forEach((itemId)=>nextSelectedItems.add(itemId));\n            }\n            changeSelection(event, nextSelectedItems);\n        }\n    };\n    return [\n        selected,\n        methods\n    ];\n}\nexport function useSelection(params) {\n    'use no memo';\n    if (params.selectionMode === 'multiselect') {\n        // selectionMode is a static value, so we can safely ignore rules-of-hooks\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        return useMultipleSelection(params);\n    }\n    // selectionMode is a static value, so we can safely ignore rules-of-hooks\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useSingleSelection(params);\n}\n"],"names":["useSelection","useSelectionState","params","selected","setSelected","useControllableState","initialState","Set","defaultState","React","useMemo","defaultSelectedItems","createSetFromIterable","state","selectedItems","changeSelection","event","nextSelectedItems","_params_onSelectionChange","onSelectionChange","call","useSingleSelection","methods","deselectItem","selectItem","itemId","toggleAllItems","process","env","NODE_ENV","Error","toggleItem","clearItems","isSelected","_selected_has","has","useMultipleSelection","delete","add","itemIds","allItemsSelected","every","clear","forEach","selectionMode"],"mappings":"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"}
+{"version":3,"sources":["useSelection.ts"],"sourcesContent":["import * as React from 'react';\nimport { SelectionHookParams, SelectionItemId, SelectionMethods } from './types';\nimport { useControllableState } from '../hooks/useControllableState';\nimport { createSetFromIterable } from '../utils/createSetFromIterable';\n\nfunction useSelectionState(params: Omit<SelectionHookParams, 'selectionMode'>) {\n  const [selected, setSelected] = useControllableState<Set<SelectionItemId>>({\n    initialState: new Set(),\n    defaultState: React.useMemo(\n      () => params.defaultSelectedItems && createSetFromIterable(params.defaultSelectedItems),\n      [params.defaultSelectedItems],\n    ),\n    state: React.useMemo(\n      () => params.selectedItems && createSetFromIterable(params.selectedItems),\n      [params.selectedItems],\n    ),\n  });\n  const changeSelection = (event: React.SyntheticEvent, nextSelectedItems: Set<SelectionItemId>) => {\n    params.onSelectionChange?.(event, { selectedItems: nextSelectedItems });\n    setSelected(nextSelectedItems);\n  };\n  return [selected, changeSelection] as const;\n}\n\nfunction useSingleSelection(params: Omit<SelectionHookParams, 'selectionMode'>) {\n  const [selected, changeSelection] = useSelectionState(params);\n  const methods: SelectionMethods = {\n    deselectItem: event => changeSelection(event, new Set()),\n    selectItem: (event, itemId) => changeSelection(event, new Set([itemId])),\n    toggleAllItems: () => {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error('[react-utilities]: `toggleAllItems` should not be used in single selection mode');\n      }\n    },\n    toggleItem: (event, itemId) => changeSelection(event, new Set([itemId])),\n    clearItems: event => changeSelection(event, new Set()),\n    isSelected: itemId => selected.has(itemId) ?? false,\n  };\n  return [selected, methods] as const;\n}\n\nfunction useMultipleSelection(params: Omit<SelectionHookParams, 'selectionMode'>) {\n  const [selected, changeSelection] = useSelectionState(params);\n  const methods: SelectionMethods = {\n    toggleItem: (event, itemId) => {\n      const nextSelectedItems = new Set(selected);\n      if (selected.has(itemId)) {\n        nextSelectedItems.delete(itemId);\n      } else {\n        nextSelectedItems.add(itemId);\n      }\n      changeSelection(event, nextSelectedItems);\n    },\n    selectItem: (event, itemId) => {\n      const nextSelectedItems = new Set(selected);\n      nextSelectedItems.add(itemId);\n      changeSelection(event, nextSelectedItems);\n    },\n    deselectItem: (event, itemId) => {\n      const nextSelectedItems = new Set(selected);\n      nextSelectedItems.delete(itemId);\n      changeSelection(event, nextSelectedItems);\n    },\n    clearItems: event => {\n      changeSelection(event, new Set());\n    },\n    isSelected: itemId => selected.has(itemId),\n    toggleAllItems: (event, itemIds) => {\n      const allItemsSelected = itemIds.every(itemId => selected.has(itemId));\n      const nextSelectedItems = new Set(selected);\n      if (allItemsSelected) {\n        nextSelectedItems.clear();\n      } else {\n        itemIds.forEach(itemId => nextSelectedItems.add(itemId));\n      }\n      changeSelection(event, nextSelectedItems);\n    },\n  };\n  return [selected, methods] as const;\n}\n\nexport function useSelection(params: SelectionHookParams) {\n  'use no memo';\n\n  if (params.selectionMode === 'multiselect') {\n    // selectionMode is a static value, so we can safely ignore rules-of-hooks\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useMultipleSelection(params);\n  }\n  // selectionMode is a static value, so we can safely ignore rules-of-hooks\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return useSingleSelection(params);\n}\n"],"names":["useSelection","useSelectionState","params","selected","setSelected","useControllableState","initialState","Set","defaultState","React","useMemo","defaultSelectedItems","createSetFromIterable","state","selectedItems","changeSelection","event","nextSelectedItems","onSelectionChange","useSingleSelection","methods","deselectItem","selectItem","itemId","toggleAllItems","process","env","NODE_ENV","Error","toggleItem","clearItems","isSelected","has","useMultipleSelection","delete","add","itemIds","allItemsSelected","every","clear","forEach","selectionMode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/ssr/SSRContext.js

@@ -9,20 +9,20 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    defaultSSRContextValue: function() {
-        return defaultSSRContextValue;
-    },
     SSRContext: function() {
         return SSRContext;
     },
-    useSSRContext: function() {
-        return useSSRContext;
-    },
     SSRProvider: function() {
         return SSRProvider;
     },
+    defaultSSRContextValue: function() {
+        return defaultSSRContextValue;
+    },
     useIsSSR: function() {
         return useIsSSR;
+    },
+    useSSRContext: function() {
+        return useSSRContext;
     }
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");

package/lib-commonjs/ssr/SSRContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["SSRContext.js"],"sourcesContent":["import * as React from 'react';\nimport { canUseDOM } from './canUseDOM';\n/**\n * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.\n *\n * @internal\n */ export const defaultSSRContextValue = {\n    current: 0\n};\nexport const SSRContext = /*#__PURE__*/ React.createContext(undefined);\n/**\n * @internal\n */ export function useSSRContext() {\n    var _React_useContext;\n    return (_React_useContext = React.useContext(SSRContext)) !== null && _React_useContext !== void 0 ? _React_useContext : defaultSSRContextValue;\n}\n/**\n * When using SSR with Fluent UI, applications must be wrapped in an SSRProvider. This ensures that auto generated ids\n * are consistent between the client and server.\n *\n * @public\n */ export const SSRProvider = (props)=>{\n    const [value] = React.useState(()=>({\n            current: 0\n        }));\n    return /*#__PURE__*/ React.createElement(SSRContext.Provider, {\n        value: value\n    }, props.children);\n};\n/**\n * Returns whether the component is currently being server side rendered or hydrated on the client. Can be used to delay\n * browser-specific rendering until after hydration. May cause re-renders on a client when is used within SSRProvider.\n */ export function useIsSSR() {\n    const isInSSRContext = useSSRContext() !== defaultSSRContextValue;\n    const [isSSR, setIsSSR] = React.useState(isInSSRContext);\n    // If we are rendering in a non-DOM environment, and there's no SSRProvider, provide a warning to hint to the\n    // developer to add one.\n    if (process.env.NODE_ENV !== 'production') {\n        if (!isInSSRContext && !canUseDOM()) {\n            // eslint-disable-next-line no-console\n            console.error(`@fluentui/react-components [${useIsSSR.name}]:\nWhen server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.\n\n\nCheck documentation at https://aka.ms/fluentui-ssr.`);\n        }\n    }\n    // If on the client, and the component was initially server rendered, then schedule a layout effect to update the\n    // component after hydration.\n    if (canUseDOM() && isInSSRContext) {\n        // This if statement technically breaks the rules of hooks, but is safe because the condition never changes after\n        // mounting.\n        // eslint-disable-next-line\n        React.useLayoutEffect(()=>{\n            setIsSSR(false);\n        }, []);\n    }\n    return isSSR;\n}\n"],"names":["defaultSSRContextValue","SSRContext","useSSRContext","SSRProvider","useIsSSR","current","React","createContext","undefined","_React_useContext","useContext","props","value","useState","createElement","Provider","children","isInSSRContext","isSSR","setIsSSR","process","env","NODE_ENV","canUseDOM","console","error","name","useLayoutEffect"],"mappings":";;;;;;;;;;;IAMiBA,sBAAsB;eAAtBA;;IAGJC,UAAU;eAAVA;;IAGOC,aAAa;eAAbA;;IASHC,WAAW;eAAXA;;IAWGC,QAAQ;eAARA;;;;iEAhCG;2BACG;AAKf,MAAMJ,yBAAyB;IACtCK,SAAS;AACb;AACO,MAAMJ,aAAa,WAAW,GAAGK,OAAMC,aAAa,CAACC;AAGjD,SAASN;IAChB,IAAIO;IACJ,OAAO,AAACA,CAAAA,oBAAoBH,OAAMI,UAAU,CAACT,WAAU,MAAO,QAAQQ,sBAAsB,KAAK,IAAIA,oBAAoBT;AAC7H;AAMW,MAAMG,cAAc,CAACQ;IAC5B,MAAM,CAACC,MAAM,GAAGN,OAAMO,QAAQ,CAAC,IAAK,CAAA;YAC5BR,SAAS;QACb,CAAA;IACJ,OAAO,WAAW,GAAGC,OAAMQ,aAAa,CAACb,WAAWc,QAAQ,EAAE;QAC1DH,OAAOA;IACX,GAAGD,MAAMK,QAAQ;AACrB;AAIW,SAASZ;IAChB,MAAMa,iBAAiBf,oBAAoBF;IAC3C,MAAM,CAACkB,OAAOC,SAAS,GAAGb,OAAMO,QAAQ,CAACI;IACzC,6GAA6G;IAC7G,wBAAwB;IACxB,IAAIG,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACvC,IAAI,CAACL,kBAAkB,CAACM,IAAAA,oBAAS,KAAI;YACjC,sCAAsC;YACtCC,QAAQC,KAAK,CAAC,CAAC,4BAA4B,EAAErB,SAASsB,IAAI,CAAC;;;;mDAIpB,CAAC;QAC5C;IACJ;IACA,iHAAiH;IACjH,6BAA6B;IAC7B,IAAIH,IAAAA,oBAAS,OAAMN,gBAAgB;QAC/B,iHAAiH;QACjH,YAAY;QACZ,2BAA2B;QAC3BX,OAAMqB,eAAe,CAAC;YAClBR,SAAS;QACb,GAAG,EAAE;IACT;IACA,OAAOD;AACX"}
+{"version":3,"sources":["SSRContext.tsx"],"sourcesContent":["import * as React from 'react';\nimport { canUseDOM } from './canUseDOM';\n\n/**\n * To support SSR, the auto incrementing id counter is stored in a context. This allows it to be reset on every request\n * to ensure the client and server are consistent.\n *\n * @internal\n */\nexport type SSRContextValue = {\n  current: number;\n};\n\n/**\n * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.\n *\n * @internal\n */\nexport const defaultSSRContextValue: SSRContextValue = {\n  current: 0,\n};\n\nexport const SSRContext = React.createContext<SSRContextValue | undefined>(undefined) as React.Context<SSRContextValue>;\n\n/**\n * @internal\n */\nexport function useSSRContext(): SSRContextValue {\n  return React.useContext(SSRContext) ?? defaultSSRContextValue;\n}\n\n/**\n * When using SSR with Fluent UI, applications must be wrapped in an SSRProvider. This ensures that auto generated ids\n * are consistent between the client and server.\n *\n * @public\n */\nexport const SSRProvider: React.FC<{ children: React.ReactNode }> = props => {\n  const [value] = React.useState<SSRContextValue>(() => ({ current: 0 }));\n\n  return <SSRContext.Provider value={value}>{props.children}</SSRContext.Provider>;\n};\n\n/**\n * Returns whether the component is currently being server side rendered or hydrated on the client. Can be used to delay\n * browser-specific rendering until after hydration. May cause re-renders on a client when is used within SSRProvider.\n */\nexport function useIsSSR(): boolean {\n  const isInSSRContext = useSSRContext() !== defaultSSRContextValue;\n  const [isSSR, setIsSSR] = React.useState(isInSSRContext);\n\n  // If we are rendering in a non-DOM environment, and there's no SSRProvider, provide a warning to hint to the\n  // developer to add one.\n  if (process.env.NODE_ENV !== 'production') {\n    if (!isInSSRContext && !canUseDOM()) {\n      // eslint-disable-next-line no-console\n      console.error(/** #__DE-INDENT__ */ `\n        @fluentui/react-components [${useIsSSR.name}]:\n        When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.\n\n\n        Check documentation at https://aka.ms/fluentui-ssr.\n      `);\n    }\n  }\n\n  // If on the client, and the component was initially server rendered, then schedule a layout effect to update the\n  // component after hydration.\n  if (canUseDOM() && isInSSRContext) {\n    // This if statement technically breaks the rules of hooks, but is safe because the condition never changes after\n    // mounting.\n    // eslint-disable-next-line\n    React.useLayoutEffect(() => {\n      setIsSSR(false);\n    }, []);\n  }\n\n  return isSSR;\n}\n"],"names":["SSRContext","SSRProvider","defaultSSRContextValue","useIsSSR","useSSRContext","current","React","createContext","undefined","useContext","props","value","useState","createElement","Provider","children","isInSSRContext","isSSR","setIsSSR","process","env","NODE_ENV","canUseDOM","console","error","name","useLayoutEffect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAsBaA,UAAAA;eAAAA;;IAeAC,WAAAA;eAAAA;;IAnBAC,sBAAAA;eAAAA;;IA6BGC,QAAAA;eAAAA;;IApBAC,aAAAA;eAAAA;;;;iEA3BO;2BACG;AAiBnB,MAAMF,yBAA0C;IACrDG,SAAS;AACX;AAEO,MAAML,aAAAA,WAAAA,GAAaM,OAAMC,aAAa,CAA8BC;AAKpE,SAASJ;QACPE;IAAP,OAAOA,CAAAA,oBAAAA,OAAMG,UAAU,CAACT,WAAAA,MAAAA,QAAjBM,sBAAAA,KAAAA,IAAAA,oBAAgCJ;AACzC;AAQO,MAAMD,cAAuDS,CAAAA;IAClE,MAAM,CAACC,MAAM,GAAGL,OAAMM,QAAQ,CAAkB,IAAO,CAAA;YAAEP,SAAS;QAAE,CAAA;IAEpE,OAAA,WAAA,GAAOC,OAAAO,aAAA,CAACb,WAAWc,QAAQ,EAAA;QAACH,OAAOA;OAAQD,MAAMK,QAAQ;AAC3D;AAMO,SAASZ;IACd,MAAMa,iBAAiBZ,oBAAoBF;IAC3C,MAAM,CAACe,OAAOC,SAAS,GAAGZ,OAAMM,QAAQ,CAACI;IAEzC,6GAA6G;IAC7G,wBAAwB;IACxB,IAAIG,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,IAAI,CAACL,kBAAkB,CAACM,IAAAA,oBAAAA,KAAa;YACnC,sCAAsC;YACtCC,QAAQC,KAAK,CAAuB,CAAC,4BACP,EAAErB,SAASsB,IAAI,CAAC;;;;mDAK9C,CAAC;QACH;IACF;IAEA,iHAAiH;IACjH,6BAA6B;IAC7B,IAAIH,IAAAA,oBAAAA,OAAeN,gBAAgB;QACjC,iHAAiH;QACjH,YAAY;QACZ,2BAA2B;QAC3BV,OAAMoB,eAAe,CAAC;YACpBR,SAAS;QACX,GAAG,EAAE;IACP;IAEA,OAAOD;AACT"}

package/lib-commonjs/ssr/canUseDOM.js.map

@@ -1 +1 @@
-{"version":3,"sources":["canUseDOM.js"],"sourcesContent":["/**\n * Verifies if an application can use DOM.\n */ export function canUseDOM() {\n    return(// eslint-disable-next-line deprecation/deprecation, no-restricted-globals\n    typeof window !== 'undefined' && !!(window.document && window.document.createElement));\n}\n"],"names":["canUseDOM","window","document","createElement"],"mappings":"AAAA;;CAEC;;;;+BAAmBA;;;eAAAA;;;AAAT,SAASA;IAChB,OACA,OAAOC,WAAW,eAAe,CAAC,CAAEA,CAAAA,OAAOC,QAAQ,IAAID,OAAOC,QAAQ,CAACC,aAAa,AAAD;AACvF"}
+{"version":3,"sources":["canUseDOM.ts"],"sourcesContent":["/**\n * Verifies if an application can use DOM.\n */\nexport function canUseDOM(): boolean {\n  return (\n    // eslint-disable-next-line deprecation/deprecation, no-restricted-globals\n    typeof window !== 'undefined' && !!(window.document && window.document.createElement)\n  );\n}\n"],"names":["canUseDOM","window","document","createElement"],"rangeMappings":";;;;;;;;;;;;;;","mappings":"AAAA;;CAEC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA;IACd,OAEE,OAAOC,WAAW,eAAe,CAAC,CAAEA,CAAAA,OAAOC,QAAQ,IAAID,OAAOC,QAAQ,CAACC,aAAa,AAAbA;AAE3E"}

package/lib-commonjs/ssr/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './canUseDOM';\nexport * from './SSRContext';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './canUseDOM';\nexport * from './SSRContext';\n"],"names":[],"rangeMappings":";;;;;;","mappings":";;;;;uBAAc;uBACA"}

package/lib-commonjs/trigger/applyTriggerPropsToChildren.js.map

@@ -1 +1 @@
-{"version":3,"sources":["applyTriggerPropsToChildren.js"],"sourcesContent":["import * as React from 'react';\nimport { isFluentTrigger } from './isFluentTrigger';\n/**\n * @internal\n * resolve the trigger props to the children, either by calling the render function, or cloning with the new props.\n */ export function applyTriggerPropsToChildren(children, triggerChildProps) {\n    if (typeof children === 'function') {\n        return children(triggerChildProps);\n    } else if (children) {\n        return cloneTriggerTree(children, triggerChildProps);\n    }\n    // Components in React should return either JSX elements or \"null\", otherwise React will throw:\n    //   Nothing was returned from render.\n    //   This usually means a return statement is missing. Or, to render nothing, return null.\n    return children || null;\n}\n/**\n * Clones a React element tree, and applies the given props to the first grandchild that is not\n * a FluentTriggerComponent or React Fragment (the same element returned by {@link getTriggerChild}).\n */ function cloneTriggerTree(child, triggerProps) {\n    if (!React.isValidElement(child) || child.type === React.Fragment) {\n        throw new Error('A trigger element must be a single element for this component. ' + \"Please ensure that you're not using React Fragments.\");\n    }\n    if (isFluentTrigger(child)) {\n        const grandchild = cloneTriggerTree(child.props.children, triggerProps);\n        return React.cloneElement(child, undefined, grandchild);\n    } else {\n        return React.cloneElement(child, triggerProps);\n    }\n}\n"],"names":["applyTriggerPropsToChildren","children","triggerChildProps","cloneTriggerTree","child","triggerProps","React","isValidElement","type","Fragment","Error","isFluentTrigger","grandchild","props","cloneElement","undefined"],"mappings":";;;;+BAKoBA;;;eAAAA;;;;iEALG;iCACS;AAIrB,SAASA,4BAA4BC,QAAQ,EAAEC,iBAAiB;IACvE,IAAI,OAAOD,aAAa,YAAY;QAChC,OAAOA,SAASC;IACpB,OAAO,IAAID,UAAU;QACjB,OAAOE,iBAAiBF,UAAUC;IACtC;IACA,+FAA+F;IAC/F,sCAAsC;IACtC,0FAA0F;IAC1F,OAAOD,YAAY;AACvB;AACA;;;CAGC,GAAG,SAASE,iBAAiBC,KAAK,EAAEC,YAAY;IAC7C,IAAI,eAACC,OAAMC,cAAc,CAACH,UAAUA,MAAMI,IAAI,KAAKF,OAAMG,QAAQ,EAAE;QAC/D,MAAM,IAAIC,MAAM,oEAAoE;IACxF;IACA,IAAIC,IAAAA,gCAAe,EAACP,QAAQ;QACxB,MAAMQ,aAAaT,iBAAiBC,MAAMS,KAAK,CAACZ,QAAQ,EAAEI;QAC1D,qBAAOC,OAAMQ,YAAY,CAACV,OAAOW,WAAWH;IAChD,OAAO;QACH,qBAAON,OAAMQ,YAAY,CAACV,OAAOC;IACrC;AACJ"}
+{"version":3,"sources":["applyTriggerPropsToChildren.ts"],"sourcesContent":["import * as React from 'react';\nimport { isFluentTrigger } from './isFluentTrigger';\nimport type { TriggerProps } from './types';\n\n/**\n * @internal\n * resolve the trigger props to the children, either by calling the render function, or cloning with the new props.\n */\nexport function applyTriggerPropsToChildren<TriggerChildProps>(\n  children: TriggerProps<TriggerChildProps>['children'],\n  triggerChildProps: TriggerChildProps,\n): React.ReactElement | null {\n  if (typeof children === 'function') {\n    return children(triggerChildProps);\n  } else if (children) {\n    return cloneTriggerTree(children, triggerChildProps);\n  }\n\n  // Components in React should return either JSX elements or \"null\", otherwise React will throw:\n  //   Nothing was returned from render.\n  //   This usually means a return statement is missing. Or, to render nothing, return null.\n  return children || null;\n}\n\n/**\n * Clones a React element tree, and applies the given props to the first grandchild that is not\n * a FluentTriggerComponent or React Fragment (the same element returned by {@link getTriggerChild}).\n */\nfunction cloneTriggerTree<TriggerChildProps>(\n  child: React.ReactNode,\n  triggerProps: TriggerChildProps,\n): React.ReactElement {\n  if (!React.isValidElement(child) || child.type === React.Fragment) {\n    throw new Error(\n      'A trigger element must be a single element for this component. ' +\n        \"Please ensure that you're not using React Fragments.\",\n    );\n  }\n\n  if (isFluentTrigger(child)) {\n    const grandchild = cloneTriggerTree(child.props.children, triggerProps);\n    return React.cloneElement(child, undefined, grandchild);\n  } else {\n    return React.cloneElement(child, triggerProps as TriggerChildProps & React.Attributes);\n  }\n}\n"],"names":["applyTriggerPropsToChildren","children","triggerChildProps","cloneTriggerTree","child","triggerProps","React","isValidElement","type","Fragment","Error","isFluentTrigger","grandchild","props","cloneElement","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;;iEARO;iCACS;AAOzB,SAASA,4BACdC,QAAqD,EACrDC,iBAAoC;IAEpC,IAAI,OAAOD,aAAa,YAAY;QAClC,OAAOA,SAASC;IAClB,OAAO,IAAID,UAAU;QACnB,OAAOE,iBAAiBF,UAAUC;IACpC;IAEA,+FAA+F;IAC/F,sCAAsC;IACtC,0FAA0F;IAC1F,OAAOD,YAAY;AACrB;AAEA;;;CAGC,GACD,SAASE,iBACPC,KAAsB,EACtBC,YAA+B;IAE/B,IAAI,eAACC,OAAMC,cAAc,CAACH,UAAUA,MAAMI,IAAI,KAAKF,OAAMG,QAAQ,EAAE;QACjE,MAAM,IAAIC,MACR,oEACE;IAEN;IAEA,IAAIC,IAAAA,gCAAAA,EAAgBP,QAAQ;QAC1B,MAAMQ,aAAaT,iBAAiBC,MAAMS,KAAK,CAACZ,QAAQ,EAAEI;QAC1D,qBAAOC,OAAMQ,YAAY,CAACV,OAAOW,WAAWH;IAC9C,OAAO;QACL,qBAAON,OAAMQ,YAAY,CAACV,OAAOC;IACnC;AACF"}

package/lib-commonjs/trigger/getTriggerChild.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getTriggerChild.js"],"sourcesContent":["import * as React from 'react';\nimport { isFluentTrigger } from './isFluentTrigger';\n/**\n * @internal\n * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).\n *\n * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,\n * it returns the first descendant that is _not_ a FluentTriggerComponent or Fragment.\n * This allows multiple triggers to be stacked, and still apply their props to the actual trigger element.\n *\n * For example, the following returns `<div id=\"child\" />`:\n * ```jsx\n * getTriggerChild(\n *   <Tooltip>\n *     <MenuTrigger>\n *       <div id=\"child\" />\n *     </MenuTrigger>\n *   </Tooltip>\n * );\n * ```\n *\n * In the case where the immediate child is not a valid element,\n * null is returned\n */ export function getTriggerChild(children) {\n    if (!React.isValidElement(children)) {\n        return null;\n    }\n    return isFluentTrigger(children) ? getTriggerChild(// FIXME: This casting should be unnecessary as isFluentTrigger is a guard type method,\n    // but for some reason it's failing on build\n    children.props.children) : children;\n}\n"],"names":["getTriggerChild","children","React","isValidElement","isFluentTrigger","props"],"mappings":";;;;+BAuBoBA;;;eAAAA;;;;iEAvBG;iCACS;AAsBrB,SAASA,gBAAgBC,QAAQ;IACxC,IAAI,eAACC,OAAMC,cAAc,CAACF,WAAW;QACjC,OAAO;IACX;IACA,OAAOG,IAAAA,gCAAe,EAACH,YAAYD,gBACnC,4CAA4C;IAC5CC,SAASI,KAAK,CAACJ,QAAQ,IAAIA;AAC/B"}
+{"version":3,"sources":["getTriggerChild.ts"],"sourcesContent":["import * as React from 'react';\nimport { isFluentTrigger } from './isFluentTrigger';\nimport type { TriggerProps } from './types';\n\n/**\n * @internal\n * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).\n *\n * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,\n * it returns the first descendant that is _not_ a FluentTriggerComponent or Fragment.\n * This allows multiple triggers to be stacked, and still apply their props to the actual trigger element.\n *\n * For example, the following returns `<div id=\"child\" />`:\n * ```jsx\n * getTriggerChild(\n *   <Tooltip>\n *     <MenuTrigger>\n *       <div id=\"child\" />\n *     </MenuTrigger>\n *   </Tooltip>\n * );\n * ```\n *\n * In the case where the immediate child is not a valid element,\n * null is returned\n */\nexport function getTriggerChild<TriggerChildProps>(\n  children: TriggerProps<TriggerChildProps>['children'],\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): (React.ReactElement<Partial<TriggerChildProps>> & { ref?: React.Ref<any> }) | null {\n  if (!React.isValidElement<TriggerChildProps>(children)) {\n    return null;\n  }\n  return isFluentTrigger(children)\n    ? getTriggerChild(\n        // FIXME: This casting should be unnecessary as isFluentTrigger is a guard type method,\n        // but for some reason it's failing on build\n        (children.props as TriggerProps).children,\n      )\n    : children;\n}\n"],"names":["getTriggerChild","children","React","isValidElement","isFluentTrigger","props"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA0BgBA;;;eAAAA;;;;iEA1BO;iCACS;AAyBzB,SAASA,gBACdC,QAAqD;IAGrD,IAAI,eAACC,OAAMC,cAAc,CAAoBF,WAAW;QACtD,OAAO;IACT;IACA,OAAOG,IAAAA,gCAAAA,EAAgBH,YACnBD,gBAEE,4CAA4C;IAC3CC,SAASI,KAAK,CAAkBJ,QAAQ,IAE3CA;AACN"}

package/lib-commonjs/trigger/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './applyTriggerPropsToChildren';\nexport * from './getTriggerChild';\nexport * from './isFluentTrigger';\nexport * from './types';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA;uBACA;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './applyTriggerPropsToChildren';\nexport * from './getTriggerChild';\nexport * from './isFluentTrigger';\nexport * from './types';\n"],"names":[],"rangeMappings":";;;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA;uBACA"}

package/lib-commonjs/trigger/isFluentTrigger.js.map

@@ -1 +1 @@
-{"version":3,"sources":["isFluentTrigger.js"],"sourcesContent":["import * as React from 'react';\n/**\n * @internal\n * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).\n * See the {@link FluentTriggerComponent} type for more info.\n */ export function isFluentTrigger(element) {\n    return Boolean(element.type.isFluentTriggerComponent);\n}\n"],"names":["isFluentTrigger","element","Boolean","type","isFluentTriggerComponent"],"mappings":";;;;+BAKoBA;;;eAAAA;;;;iEALG;AAKZ,SAASA,gBAAgBC,OAAO;IACvC,OAAOC,QAAQD,QAAQE,IAAI,CAACC,wBAAwB;AACxD"}
+{"version":3,"sources":["isFluentTrigger.ts"],"sourcesContent":["import * as React from 'react';\nimport type { FluentTriggerComponent, TriggerProps } from './types';\n\n/**\n * @internal\n * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).\n * See the {@link FluentTriggerComponent} type for more info.\n */\nexport function isFluentTrigger(element: React.ReactElement): element is React.ReactElement<TriggerProps> {\n  return Boolean((element.type as FluentTriggerComponent).isFluentTriggerComponent);\n}\n"],"names":["isFluentTrigger","element","Boolean","type","isFluentTriggerComponent"],"rangeMappings":";;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;;iEARO;AAQhB,SAASA,gBAAgBC,OAA2B;IACzD,OAAOC,QAAQD,QAASE,IAAI,CAA4BC,wBAAwB;AAClF"}

package/lib-commonjs/trigger/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.js"],"sourcesContent":["import * as React from 'react';\n"],"names":[],"mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * @internal\n * Allows a component to be tagged as a FluentUI trigger component.\n *\n * Triggers are special-case components: they attach event listeners and other props on their child,\n * and use them to trigger another component to show. Examples include `MenuTrigger` and `Tooltip`.\n *\n * A component can be tagged as a trigger as follows:\n * ```ts\n * const MyComponent: React.FC<MyComponentProps> & FluentTriggerComponent = ...;\n *\n * MyComponent.isFluentTriggerComponent = true; // MUST also set this to true\n * ```\n */\nexport type FluentTriggerComponent = {\n  isFluentTriggerComponent?: boolean;\n};\n\n/**\n * A trigger may have a children that could be either:\n * 1. A single element\n * 2. A render function that will receive properties and must return a valid element or null\n * 3. null or undefined\n */\nexport type TriggerProps<TriggerChildProps = unknown> = {\n  children?: React.ReactElement | ((props: TriggerChildProps) => React.ReactElement | null) | null;\n};\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/utils/clamp.js.map

@@ -1 +1 @@
-{"version":3,"sources":["clamp.js"],"sourcesContent":["/**\n * @internal\n * Clamps `value` to a number between the min and max.\n *\n * @param value - the value to be clamped\n * @param min - the lowest valid value\n * @param max - the highest valid value\n */ export const clamp = (value, min, max)=>Math.max(min, Math.min(max, value || 0));\n"],"names":["clamp","value","min","max","Math"],"mappings":"AAAA;;;;;;;CAOC;;;;+BAAgBA;;;eAAAA;;;AAAN,MAAMA,QAAQ,CAACC,OAAOC,KAAKC,MAAMC,KAAKD,GAAG,CAACD,KAAKE,KAAKF,GAAG,CAACC,KAAKF,SAAS"}
+{"version":3,"sources":["clamp.ts"],"sourcesContent":["/**\n * @internal\n * Clamps `value` to a number between the min and max.\n *\n * @param value - the value to be clamped\n * @param min - the lowest valid value\n * @param max - the highest valid value\n */\nexport const clamp = (value: number, min: number, max: number): number => Math.max(min, Math.min(max, value || 0));\n"],"names":["clamp","value","min","max","Math"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;;CAOC;;;;+BACYA;;;eAAAA;;;AAAN,MAAMA,QAAQ,CAACC,OAAeC,KAAaC,MAAwBC,KAAKD,GAAG,CAACD,KAAKE,KAAKF,GAAG,CAACC,KAAKF,SAAS"}

package/lib-commonjs/utils/createSetFromIterable.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createSetFromIterable.js"],"sourcesContent":["/**\n * Creates a set from a given iterable, in case the iterable is a set itself, returns the given set instead.\n */ export function createSetFromIterable(iterable) {\n    return iterable instanceof Set ? iterable : new Set(iterable);\n}\n"],"names":["createSetFromIterable","iterable","Set"],"mappings":"AAAA;;CAEC;;;;+BAAmBA;;;eAAAA;;;AAAT,SAASA,sBAAsBC,QAAQ;IAC9C,OAAOA,oBAAoBC,MAAMD,WAAW,IAAIC,IAAID;AACxD"}
+{"version":3,"sources":["createSetFromIterable.ts"],"sourcesContent":["/**\n * Creates a set from a given iterable, in case the iterable is a set itself, returns the given set instead.\n */\nexport function createSetFromIterable<V>(iterable: Iterable<V>): Set<V> {\n  return iterable instanceof Set ? iterable : new Set(iterable);\n}\n"],"names":["createSetFromIterable","iterable","Set"],"rangeMappings":";;;;;;;;;;;;;;","mappings":"AAAA;;CAEC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,sBAAyBC,QAAqB;IAC5D,OAAOA,oBAAoBC,MAAMD,WAAW,IAAIC,IAAID;AACtD"}

package/lib-commonjs/utils/getNativeElementProps.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getNativeElementProps.js"],"sourcesContent":["import * as React from 'react';\nimport { labelProperties, audioProperties, videoProperties, olProperties, liProperties, anchorProperties, buttonProperties, inputProperties, textAreaProperties, selectProperties, optionProperties, tableProperties, trProperties, thProperties, tdProperties, colGroupProperties, colProperties, fieldsetProperties, formProperties, iframeProperties, imgProperties, htmlElementProperties, getNativeProps, timeProperties, dialogProperties } from './properties';\nconst nativeElementMap = {\n    label: labelProperties,\n    audio: audioProperties,\n    video: videoProperties,\n    ol: olProperties,\n    li: liProperties,\n    a: anchorProperties,\n    button: buttonProperties,\n    input: inputProperties,\n    textarea: textAreaProperties,\n    select: selectProperties,\n    option: optionProperties,\n    table: tableProperties,\n    tr: trProperties,\n    th: thProperties,\n    td: tdProperties,\n    colGroup: colGroupProperties,\n    col: colProperties,\n    fieldset: fieldsetProperties,\n    form: formProperties,\n    iframe: iframeProperties,\n    img: imgProperties,\n    time: timeProperties,\n    dialog: dialogProperties\n};\n/**\n * Given an element tagname and user props, filters the props to only allowed props for the given\n * element type.\n * @param tagName - Tag name (e.g. \"div\")\n * @param props - Props object\n * @param excludedPropNames - List of props to disallow\n *\n * @deprecated use getIntrinsicElementProps instead, it is a type-safe version of this method\n */ // eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getNativeElementProps(tagName, props, excludedPropNames) {\n    const allowedPropNames = tagName && nativeElementMap[tagName] || htmlElementProperties;\n    allowedPropNames.as = 1;\n    return getNativeProps(props, allowedPropNames, excludedPropNames);\n}\n/**\n * Splits the native props into ones that go to the `root` slot, and ones that go to the primary slot.\n *\n * This function is only for use with components that have a primary slot other than `root`.\n * Most components should use {@link getNativeElementProps} for their root slot if it is the primary slot.\n *\n * @returns An object containing the native props for the `root` and primary slots.\n */ export const getPartitionedNativeProps = ({ primarySlotTagName, props, excludedPropNames })=>{\n    return {\n        root: {\n            style: props.style,\n            className: props.className\n        },\n        // eslint-disable-next-line deprecation/deprecation\n        primary: getNativeElementProps(primarySlotTagName, props, [\n            ...excludedPropNames || [],\n            'style',\n            'className'\n        ])\n    };\n};\n"],"names":["getNativeElementProps","getPartitionedNativeProps","nativeElementMap","label","labelProperties","audio","audioProperties","video","videoProperties","ol","olProperties","li","liProperties","a","anchorProperties","button","buttonProperties","input","inputProperties","textarea","textAreaProperties","select","selectProperties","option","optionProperties","table","tableProperties","tr","trProperties","th","thProperties","td","tdProperties","colGroup","colGroupProperties","col","colProperties","fieldset","fieldsetProperties","form","formProperties","iframe","iframeProperties","img","imgProperties","time","timeProperties","dialog","dialogProperties","tagName","props","excludedPropNames","allowedPropNames","htmlElementProperties","as","getNativeProps","primarySlotTagName","root","style","className","primary"],"mappings":";;;;;;;;;;;IAoCgBA,qBAAqB;eAArBA;;IAYCC,yBAAyB;eAAzBA;;;;iEAhDM;4BACga;AACvb,MAAMC,mBAAmB;IACrBC,OAAOC,2BAAe;IACtBC,OAAOC,2BAAe;IACtBC,OAAOC,2BAAe;IACtBC,IAAIC,wBAAY;IAChBC,IAAIC,wBAAY;IAChBC,GAAGC,4BAAgB;IACnBC,QAAQC,4BAAgB;IACxBC,OAAOC,2BAAe;IACtBC,UAAUC,8BAAkB;IAC5BC,QAAQC,4BAAgB;IACxBC,QAAQC,4BAAgB;IACxBC,OAAOC,2BAAe;IACtBC,IAAIC,wBAAY;IAChBC,IAAIC,wBAAY;IAChBC,IAAIC,wBAAY;IAChBC,UAAUC,8BAAkB;IAC5BC,KAAKC,yBAAa;IAClBC,UAAUC,8BAAkB;IAC5BC,MAAMC,0BAAc;IACpBC,QAAQC,4BAAgB;IACxBC,KAAKC,yBAAa;IAClBC,MAAMC,0BAAc;IACpBC,QAAQC,4BAAgB;AAC5B;AAUO,SAAShD,sBAAsBiD,OAAO,EAAEC,KAAK,EAAEC,iBAAiB;IACnE,MAAMC,mBAAmBH,WAAW/C,gBAAgB,CAAC+C,QAAQ,IAAII,iCAAqB;IACtFD,iBAAiBE,EAAE,GAAG;IACtB,OAAOC,IAAAA,0BAAc,EAACL,OAAOE,kBAAkBD;AACnD;AAQW,MAAMlD,4BAA4B,CAAC,EAAEuD,kBAAkB,EAAEN,KAAK,EAAEC,iBAAiB,EAAE;IAC1F,OAAO;QACHM,MAAM;YACFC,OAAOR,MAAMQ,KAAK;YAClBC,WAAWT,MAAMS,SAAS;QAC9B;QACA,mDAAmD;QACnDC,SAAS5D,sBAAsBwD,oBAAoBN,OAAO;eACnDC,qBAAqB,EAAE;YAC1B;YACA;SACH;IACL;AACJ"}
+{"version":3,"sources":["getNativeElementProps.ts"],"sourcesContent":["import * as React from 'react';\nimport {\n  labelProperties,\n  audioProperties,\n  videoProperties,\n  olProperties,\n  liProperties,\n  anchorProperties,\n  buttonProperties,\n  inputProperties,\n  textAreaProperties,\n  selectProperties,\n  optionProperties,\n  tableProperties,\n  trProperties,\n  thProperties,\n  tdProperties,\n  colGroupProperties,\n  colProperties,\n  fieldsetProperties,\n  formProperties,\n  iframeProperties,\n  imgProperties,\n  htmlElementProperties,\n  getNativeProps,\n  timeProperties,\n  dialogProperties,\n} from './properties';\n\nconst nativeElementMap: Record<string, Record<string, number>> = {\n  label: labelProperties,\n  audio: audioProperties,\n  video: videoProperties,\n  ol: olProperties,\n  li: liProperties,\n  a: anchorProperties,\n  button: buttonProperties,\n  input: inputProperties,\n  textarea: textAreaProperties,\n  select: selectProperties,\n  option: optionProperties,\n  table: tableProperties,\n  tr: trProperties,\n  th: thProperties,\n  td: tdProperties,\n  colGroup: colGroupProperties,\n  col: colProperties,\n  fieldset: fieldsetProperties,\n  form: formProperties,\n  iframe: iframeProperties,\n  img: imgProperties,\n  time: timeProperties,\n  dialog: dialogProperties,\n};\n\n/**\n * Given an element tagname and user props, filters the props to only allowed props for the given\n * element type.\n * @param tagName - Tag name (e.g. \"div\")\n * @param props - Props object\n * @param excludedPropNames - List of props to disallow\n *\n * @deprecated use getIntrinsicElementProps instead, it is a type-safe version of this method\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getNativeElementProps<TAttributes extends React.HTMLAttributes<any>>(\n  tagName: string,\n  props: {},\n  excludedPropNames?: string[],\n): TAttributes {\n  const allowedPropNames = (tagName && nativeElementMap[tagName]) || htmlElementProperties;\n  allowedPropNames.as = 1;\n\n  return getNativeProps(props, allowedPropNames, excludedPropNames);\n}\n\n/**\n * Splits the native props into ones that go to the `root` slot, and ones that go to the primary slot.\n *\n * This function is only for use with components that have a primary slot other than `root`.\n * Most components should use {@link getNativeElementProps} for their root slot if it is the primary slot.\n *\n * @returns An object containing the native props for the `root` and primary slots.\n */\nexport const getPartitionedNativeProps = <\n  Props extends Pick<React.HTMLAttributes<HTMLElement>, 'style' | 'className'>,\n  ExcludedPropKeys extends Extract<keyof Props, string> = never,\n>({\n  primarySlotTagName,\n  props,\n  excludedPropNames,\n}: {\n  /** The primary slot's element type (e.g. 'div') */\n  primarySlotTagName: keyof JSX.IntrinsicElements;\n\n  /** The component's props object */\n  props: Props;\n\n  /** List of native props to exclude from the returned value */\n  excludedPropNames?: ExcludedPropKeys[];\n}) => {\n  return {\n    root: { style: props.style, className: props.className },\n    // eslint-disable-next-line deprecation/deprecation\n    primary: getNativeElementProps<Omit<Props, ExcludedPropKeys>>(primarySlotTagName, props, [\n      ...(excludedPropNames || []),\n      'style',\n      'className',\n    ]),\n  };\n};\n"],"names":["getNativeElementProps","getPartitionedNativeProps","nativeElementMap","label","labelProperties","audio","audioProperties","video","videoProperties","ol","olProperties","li","liProperties","a","anchorProperties","button","buttonProperties","input","inputProperties","textarea","textAreaProperties","select","selectProperties","option","optionProperties","table","tableProperties","tr","trProperties","th","thProperties","td","tdProperties","colGroup","colGroupProperties","col","colProperties","fieldset","fieldsetProperties","form","formProperties","iframe","iframeProperties","img","imgProperties","time","timeProperties","dialog","dialogProperties","tagName","props","excludedPropNames","allowedPropNames","htmlElementProperties","as","getNativeProps","primarySlotTagName","root","style","className","primary"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAiEgBA,qBAAAA;eAAAA;;IAmBHC,yBAAAA;eAAAA;;;;iEApFU;4BA2BhB;AAEP,MAAMC,mBAA2D;IAC/DC,OAAOC,2BAAAA;IACPC,OAAOC,2BAAAA;IACPC,OAAOC,2BAAAA;IACPC,IAAIC,wBAAAA;IACJC,IAAIC,wBAAAA;IACJC,GAAGC,4BAAAA;IACHC,QAAQC,4BAAAA;IACRC,OAAOC,2BAAAA;IACPC,UAAUC,8BAAAA;IACVC,QAAQC,4BAAAA;IACRC,QAAQC,4BAAAA;IACRC,OAAOC,2BAAAA;IACPC,IAAIC,wBAAAA;IACJC,IAAIC,wBAAAA;IACJC,IAAIC,wBAAAA;IACJC,UAAUC,8BAAAA;IACVC,KAAKC,yBAAAA;IACLC,UAAUC,8BAAAA;IACVC,MAAMC,0BAAAA;IACNC,QAAQC,4BAAAA;IACRC,KAAKC,yBAAAA;IACLC,MAAMC,0BAAAA;IACNC,QAAQC,4BAAAA;AACV;AAYO,SAAShD,sBACdiD,OAAe,EACfC,KAAS,EACTC,iBAA4B;IAE5B,MAAMC,mBAAmBH,WAAY/C,gBAAgB,CAAC+C,QAAQ,IAAKI,iCAAAA;IACnED,iBAAiBE,EAAE,GAAG;IAEtB,OAAOC,IAAAA,0BAAAA,EAAeL,OAAOE,kBAAkBD;AACjD;AAUO,MAAMlD,4BAA4B,CAGvC,EACAuD,kBAAkB,EAClBN,KAAK,EACLC,iBAAiB,EAUlB;IACC,OAAO;QACLM,MAAM;YAAEC,OAAOR,MAAMQ,KAAK;YAAEC,WAAWT,MAAMS,SAAS;QAAC;QACvD,mDAAmD;QACnDC,SAAS5D,sBAAqDwD,oBAAoBN,OAAO;eACnFC,qBAAqB,EAAE;YAC3B;YACA;SACD;IACH;AACF"}

package/lib-commonjs/utils/getRTLSafeKey.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getRTLSafeKey.js"],"sourcesContent":["/**\n * @internal\n * Finds and swaps a provided key for it's right to left format.\n */ export const getRTLSafeKey = (key, dir)=>{\n    if (dir === 'rtl') {\n        switch(key){\n            case 'ArrowLeft':\n                {\n                    return 'ArrowRight';\n                }\n            case 'ArrowRight':\n                {\n                    return 'ArrowLeft';\n                }\n        }\n    }\n    return key;\n};\n"],"names":["getRTLSafeKey","key","dir"],"mappings":"AAAA;;;CAGC;;;;+BAAgBA;;;eAAAA;;;AAAN,MAAMA,gBAAgB,CAACC,KAAKC;IACnC,IAAIA,QAAQ,OAAO;QACf,OAAOD;YACH,KAAK;gBACD;oBACI,OAAO;gBACX;YACJ,KAAK;gBACD;oBACI,OAAO;gBACX;QACR;IACJ;IACA,OAAOA;AACX"}
+{"version":3,"sources":["getRTLSafeKey.ts"],"sourcesContent":["/**\n * @internal\n * Finds and swaps a provided key for it's right to left format.\n */\nexport const getRTLSafeKey = (key: string, dir: 'ltr' | 'rtl') => {\n  if (dir === 'rtl') {\n    switch (key) {\n      case 'ArrowLeft': {\n        return 'ArrowRight';\n      }\n\n      case 'ArrowRight': {\n        return 'ArrowLeft';\n      }\n    }\n  }\n\n  return key;\n};\n"],"names":["getRTLSafeKey","key","dir"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;CAGC;;;;+BACYA;;;eAAAA;;;AAAN,MAAMA,gBAAgB,CAACC,KAAaC;IACzC,IAAIA,QAAQ,OAAO;QACjB,OAAQD;YACN,KAAK;gBAAa;oBAChB,OAAO;gBACT;YAEA,KAAK;gBAAc;oBACjB,OAAO;gBACT;QACF;IACF;IAEA,OAAOA;AACT"}

package/lib-commonjs/utils/getReactCallbackName.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getReactCallbackName.js"],"sourcesContent":["import * as React from 'react';\n/**\n * React.SyntheticEvent contains name of a callback that should be fired, this function returns it.\n *\n * Ideally, it should also distinguish regular and \"capture\" callbacks, but it's possible only with React 17 as\n * \".eventPhase\" there has proper value, see https://github.com/facebook/react/pull/19244. In React 16 all events\n * are handled in bubble phase.\n */ export function getReactCallbackName(event) {\n    if (event._reactName) {\n        return event._reactName;\n    }\n    if (event.dispatchConfig) {\n        if (event.dispatchConfig.registrationName) {\n            return event.dispatchConfig.registrationName;\n        }\n        return event.dispatchConfig.phasedRegistrationNames.bubbled;\n    }\n    if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error(`@fluentui/react-utilities [${getReactCallbackName.name}]:\nPassed React.SyntheticEvent does not contain \".dispatchConfig\" or \"._reactName\". This should not happen, please report it to https://github.com/microsoft/fluentui.`);\n    }\n}\n"],"names":["getReactCallbackName","event","_reactName","dispatchConfig","registrationName","phasedRegistrationNames","bubbled","process","env","NODE_ENV","console","error","name"],"mappings":";;;;+BAOoBA;;;eAAAA;;;;iEAPG;AAOZ,SAASA,qBAAqBC,KAAK;IAC1C,IAAIA,MAAMC,UAAU,EAAE;QAClB,OAAOD,MAAMC,UAAU;IAC3B;IACA,IAAID,MAAME,cAAc,EAAE;QACtB,IAAIF,MAAME,cAAc,CAACC,gBAAgB,EAAE;YACvC,OAAOH,MAAME,cAAc,CAACC,gBAAgB;QAChD;QACA,OAAOH,MAAME,cAAc,CAACE,uBAAuB,CAACC,OAAO;IAC/D;IACA,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACvC,sCAAsC;QACtCC,QAAQC,KAAK,CAAC,CAAC,2BAA2B,EAAEX,qBAAqBY,IAAI,CAAC;mKACqF,CAAC;IAChK;AACJ"}
+{"version":3,"sources":["getReactCallbackName.ts"],"sourcesContent":["import * as React from 'react';\n\ninterface ReactSyntheticEvent extends React.SyntheticEvent<unknown> {\n  // React 17/18\n  // See https://github.com/facebook/react/pull/19236\n  _reactName?: string;\n\n  // React 16\n  dispatchConfig?: {\n    registrationName: string;\n    phasedRegistrationNames: {\n      bubbled: string;\n      captured: string;\n    };\n  };\n}\n\ntype NonUndefined<A> = A extends undefined ? never : A;\ntype FunctionKeys<T extends object> = {\n  [K in keyof T]-?: NonUndefined<T[K]> extends Function ? K : never;\n}[keyof T];\n\nexport type ReactCallbackName = FunctionKeys<React.DOMAttributes<unknown>>;\n\n/**\n * React.SyntheticEvent contains name of a callback that should be fired, this function returns it.\n *\n * Ideally, it should also distinguish regular and \"capture\" callbacks, but it's possible only with React 17 as\n * \".eventPhase\" there has proper value, see https://github.com/facebook/react/pull/19244. In React 16 all events\n * are handled in bubble phase.\n */\nexport function getReactCallbackName(event: ReactSyntheticEvent): ReactCallbackName | undefined {\n  if (event._reactName) {\n    return event._reactName as ReactCallbackName;\n  }\n\n  if (event.dispatchConfig) {\n    if (event.dispatchConfig.registrationName) {\n      return event.dispatchConfig.registrationName as ReactCallbackName;\n    }\n\n    return event.dispatchConfig.phasedRegistrationNames.bubbled as ReactCallbackName;\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line no-console\n    console.error(/** #__DE-INDENT__ */ `\n      @fluentui/react-utilities [${getReactCallbackName.name}]:\n      Passed React.SyntheticEvent does not contain \".dispatchConfig\" or \"._reactName\". This should not happen, please report it to https://github.com/microsoft/fluentui.\n    `);\n  }\n}\n"],"names":["getReactCallbackName","event","_reactName","dispatchConfig","registrationName","phasedRegistrationNames","bubbled","process","env","NODE_ENV","console","error","name"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA+BgBA;;;eAAAA;;;;iEA/BO;AA+BhB,SAASA,qBAAqBC,KAA0B;IAC7D,IAAIA,MAAMC,UAAU,EAAE;QACpB,OAAOD,MAAMC,UAAU;IACzB;IAEA,IAAID,MAAME,cAAc,EAAE;QACxB,IAAIF,MAAME,cAAc,CAACC,gBAAgB,EAAE;YACzC,OAAOH,MAAME,cAAc,CAACC,gBAAgB;QAC9C;QAEA,OAAOH,MAAME,cAAc,CAACE,uBAAuB,CAACC,OAAO;IAC7D;IAEA,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,sCAAsC;QACtCC,QAAQC,KAAK,CAAuB,CAAC,2BACR,EAAEX,qBAAqBY,IAAI,CAAC;mKAEzD,CAAC;IACH;AACF"}

package/lib-commonjs/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './clamp';\nexport * from './getNativeElementProps';\nexport * from './getRTLSafeKey';\nexport * from './mergeCallbacks';\nexport * from './omit';\nexport * from './properties';\nexport * from './isHTMLElement';\nexport * from './isInteractiveHTMLElement';\nexport * from './priorityQueue';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './clamp';\nexport * from './getNativeElementProps';\nexport * from './getRTLSafeKey';\nexport * from './mergeCallbacks';\nexport * from './omit';\nexport * from './properties';\nexport * from './isHTMLElement';\nexport * from './isInteractiveHTMLElement';\nexport * from './priorityQueue';\n"],"names":[],"rangeMappings":";;;;;;;;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA"}

package/lib-commonjs/utils/isHTMLElement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["isHTMLElement.js"],"sourcesContent":["/**\n * Verifies if a given node is an HTMLElement,\n * this method works seamlessly with frames and elements from different documents\n *\n * This is preferred over simply using `instanceof`.\n * Since `instanceof` might be problematic while operating with [multiple realms](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)\n *\n * @example\n * ```ts\n * isHTMLElement(event.target) && event.target.focus()\n * isHTMLElement(event.target, {constructorName: 'HTMLInputElement'}) && event.target.value // some value\n * ```\n *\n */ export function isHTMLElement(element, options) {\n    var _typedElement_ownerDocument;\n    const typedElement = element;\n    var _options_constructorName;\n    return Boolean((typedElement === null || typedElement === void 0 ? void 0 : (_typedElement_ownerDocument = typedElement.ownerDocument) === null || _typedElement_ownerDocument === void 0 ? void 0 : _typedElement_ownerDocument.defaultView) && typedElement instanceof typedElement.ownerDocument.defaultView[(_options_constructorName = options === null || options === void 0 ? void 0 : options.constructorName) !== null && _options_constructorName !== void 0 ? _options_constructorName : 'HTMLElement']);\n}\n"],"names":["isHTMLElement","element","options","_typedElement_ownerDocument","typedElement","_options_constructorName","Boolean","ownerDocument","defaultView","constructorName"],"mappings":"AAAA;;;;;;;;;;;;;CAaC;;;;+BAAmBA;;;eAAAA;;;AAAT,SAASA,cAAcC,OAAO,EAAEC,OAAO;IAC9C,IAAIC;IACJ,MAAMC,eAAeH;IACrB,IAAII;IACJ,OAAOC,QAAQ,AAACF,CAAAA,iBAAiB,QAAQA,iBAAiB,KAAK,IAAI,KAAK,IAAI,AAACD,CAAAA,8BAA8BC,aAAaG,aAAa,AAAD,MAAO,QAAQJ,gCAAgC,KAAK,IAAI,KAAK,IAAIA,4BAA4BK,WAAW,AAAD,KAAMJ,wBAAwBA,aAAaG,aAAa,CAACC,WAAW,CAAC,AAACH,CAAAA,2BAA2BH,YAAY,QAAQA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQO,eAAe,AAAD,MAAO,QAAQJ,6BAA6B,KAAK,IAAIA,2BAA2B,cAAc;AACtf"}
+{"version":3,"sources":["isHTMLElement.ts"],"sourcesContent":["/**\n * Verifies if a given node is an HTMLElement,\n * this method works seamlessly with frames and elements from different documents\n *\n * This is preferred over simply using `instanceof`.\n * Since `instanceof` might be problematic while operating with [multiple realms](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)\n *\n * @example\n * ```ts\n * isHTMLElement(event.target) && event.target.focus()\n * isHTMLElement(event.target, {constructorName: 'HTMLInputElement'}) && event.target.value // some value\n * ```\n *\n */\nexport function isHTMLElement<ConstructorName extends HTMLElementConstructorName = 'HTMLElement'>(\n  element?: unknown,\n  options?: {\n    /**\n     * Can be used to provide a custom constructor instead of `HTMLElement`,\n     * Like `HTMLInputElement` for example.\n     */\n    constructorName?: ConstructorName;\n  },\n): element is InstanceType<(typeof globalThis)[ConstructorName]> {\n  const typedElement = element as Node | null | undefined;\n  return Boolean(\n    typedElement?.ownerDocument?.defaultView &&\n      typedElement instanceof typedElement.ownerDocument.defaultView[options?.constructorName ?? 'HTMLElement'],\n  );\n}\n\n/**\n * @internal\n */\nexport type HTMLElementConstructorName =\n  | 'HTMLElement'\n  | 'HTMLAnchorElement'\n  | 'HTMLAreaElement'\n  | 'HTMLAudioElement'\n  | 'HTMLBaseElement'\n  | 'HTMLBodyElement'\n  | 'HTMLBRElement'\n  | 'HTMLButtonElement'\n  | 'HTMLCanvasElement'\n  | 'HTMLDataElement'\n  | 'HTMLDataListElement'\n  | 'HTMLDetailsElement'\n  // NOTE: dialog is not supported in safari 14, also it was removed from lib-dom starting typescript 4.4\n  // | 'HTMLDialogElement'\n  | 'HTMLDivElement'\n  | 'HTMLDListElement'\n  | 'HTMLEmbedElement'\n  | 'HTMLFieldSetElement'\n  | 'HTMLFormElement'\n  | 'HTMLHeadingElement'\n  | 'HTMLHeadElement'\n  | 'HTMLHRElement'\n  | 'HTMLHtmlElement'\n  | 'HTMLIFrameElement'\n  | 'HTMLImageElement'\n  | 'HTMLInputElement'\n  | 'HTMLModElement'\n  | 'HTMLLabelElement'\n  | 'HTMLLegendElement'\n  | 'HTMLLIElement'\n  | 'HTMLLinkElement'\n  | 'HTMLMapElement'\n  | 'HTMLMetaElement'\n  | 'HTMLMeterElement'\n  | 'HTMLObjectElement'\n  | 'HTMLOListElement'\n  | 'HTMLOptGroupElement'\n  | 'HTMLOptionElement'\n  | 'HTMLOutputElement'\n  | 'HTMLParagraphElement'\n  | 'HTMLParamElement'\n  | 'HTMLPreElement'\n  | 'HTMLProgressElement'\n  | 'HTMLQuoteElement'\n  | 'HTMLSlotElement'\n  | 'HTMLScriptElement'\n  | 'HTMLSelectElement'\n  | 'HTMLSourceElement'\n  | 'HTMLSpanElement'\n  | 'HTMLStyleElement'\n  | 'HTMLTableElement'\n  | 'HTMLTableColElement'\n  | 'HTMLTableRowElement'\n  | 'HTMLTableSectionElement'\n  | 'HTMLTemplateElement'\n  | 'HTMLTextAreaElement'\n  | 'HTMLTimeElement'\n  | 'HTMLTitleElement'\n  | 'HTMLTrackElement'\n  | 'HTMLUListElement'\n  | 'HTMLVideoElement';\n"],"names":["isHTMLElement","element","options","typedElement","Boolean","ownerDocument","defaultView","constructorName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;;;;;;;;CAaC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,cACdC,OAAiB,EACjBC,OAMC;QAICC;IAFF,MAAMA,eAAeF;QAG8CC;IAFnE,OAAOE,QACLD,CAAAA,iBAAAA,QAAAA,iBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,8BAAAA,aAAcE,aAAa,AAAbA,MAAa,QAA3BF,gCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,4BAA6BG,WAAW,AAAXA,KAC3BH,wBAAwBA,aAAaE,aAAa,CAACC,WAAW,CAACJ,CAAAA,2BAAAA,YAAAA,QAAAA,YAAAA,KAAAA,IAAAA,KAAAA,IAAAA,QAASK,eAAe,AAAfA,MAAe,QAAxBL,6BAAAA,KAAAA,IAAAA,2BAA4B,cAAc;AAE/G"}

package/lib-commonjs/utils/isInteractiveHTMLElement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["isInteractiveHTMLElement.js"],"sourcesContent":["import { isHTMLElement } from './isHTMLElement';\n/**\n * @internal\n * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys\n */ export function isInteractiveHTMLElement(element) {\n    if (!isHTMLElement(element)) {\n        return false;\n    }\n    const { tagName } = element;\n    switch(tagName){\n        case 'BUTTON':\n        case 'A':\n        case 'INPUT':\n        case 'TEXTAREA':\n            return true;\n    }\n    return element.isContentEditable;\n}\n"],"names":["isInteractiveHTMLElement","element","isHTMLElement","tagName","isContentEditable"],"mappings":";;;;+BAIoBA;;;eAAAA;;;+BAJU;AAInB,SAASA,yBAAyBC,OAAO;IAChD,IAAI,CAACC,IAAAA,4BAAa,EAACD,UAAU;QACzB,OAAO;IACX;IACA,MAAM,EAAEE,OAAO,EAAE,GAAGF;IACpB,OAAOE;QACH,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACD,OAAO;IACf;IACA,OAAOF,QAAQG,iBAAiB;AACpC"}
+{"version":3,"sources":["isInteractiveHTMLElement.ts"],"sourcesContent":["import { isHTMLElement } from './isHTMLElement';\n\n/**\n * @internal\n * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys\n */\nexport function isInteractiveHTMLElement(element: unknown) {\n  if (!isHTMLElement(element)) {\n    return false;\n  }\n\n  const { tagName } = element;\n  switch (tagName) {\n    case 'BUTTON':\n    case 'A':\n    case 'INPUT':\n    case 'TEXTAREA':\n      return true;\n  }\n\n  return element.isContentEditable;\n}\n"],"names":["isInteractiveHTMLElement","element","isHTMLElement","tagName","isContentEditable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMgBA;;;eAAAA;;;+BANc;AAMvB,SAASA,yBAAyBC,OAAgB;IACvD,IAAI,CAACC,IAAAA,4BAAAA,EAAcD,UAAU;QAC3B,OAAO;IACT;IAEA,MAAM,EAAEE,OAAO,EAAE,GAAGF;IACpB,OAAQE;QACN,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACH,OAAO;IACX;IAEA,OAAOF,QAAQG,iBAAiB;AAClC"}

package/lib-commonjs/utils/mergeCallbacks.js.map

@@ -1 +1 @@
-{"version":3,"sources":["mergeCallbacks.js"],"sourcesContent":["/**\n * @internal\n * Combine two event callbacks into a single callback function that calls each one in order.\n *\n * Usage example:\n * ```ts\n * state.slot.onChange = mergeCallbacks(state.slot.onChange, ev => {\n *   // Handle onChange\n * });\n * ```\n *\n * The primary use is to avoid the need to capture an existing callback (`state.slot.onChange` in the example) to a\n * local variable before replacing with a new listener that calls the existing one. This helps avoid bugs like:\n * * Infinite recursion by calling the re-assigned state.slot.onChange if it's not captured to a local variable.\n * * Missing a call to the original onChange due to an early return or other conditional.\n *\n * If you need a callback that is stable between renders, wrap the result in {@link useEventCallback}.\n *\n * @param callback1 - The first callback to be called, or undefined\n * @param callback2 - The second callback to be called, or undefined\n *\n * @returns A function that that calls the provided functions in order\n */ export function mergeCallbacks(callback1, callback2) {\n    return (...args)=>{\n        callback1 === null || callback1 === void 0 ? void 0 : callback1(...args);\n        callback2 === null || callback2 === void 0 ? void 0 : callback2(...args);\n    };\n}\n"],"names":["mergeCallbacks","callback1","callback2","args"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC;;;;+BAAmBA;;;eAAAA;;;AAAT,SAASA,eAAeC,SAAS,EAAEC,SAAS;IACnD,OAAO,CAAC,GAAGC;QACPF,cAAc,QAAQA,cAAc,KAAK,IAAI,KAAK,IAAIA,aAAaE;QACnED,cAAc,QAAQA,cAAc,KAAK,IAAI,KAAK,IAAIA,aAAaC;IACvE;AACJ"}
+{"version":3,"sources":["mergeCallbacks.ts"],"sourcesContent":["/**\n * @internal\n * Combine two event callbacks into a single callback function that calls each one in order.\n *\n * Usage example:\n * ```ts\n * state.slot.onChange = mergeCallbacks(state.slot.onChange, ev => {\n *   // Handle onChange\n * });\n * ```\n *\n * The primary use is to avoid the need to capture an existing callback (`state.slot.onChange` in the example) to a\n * local variable before replacing with a new listener that calls the existing one. This helps avoid bugs like:\n * * Infinite recursion by calling the re-assigned state.slot.onChange if it's not captured to a local variable.\n * * Missing a call to the original onChange due to an early return or other conditional.\n *\n * If you need a callback that is stable between renders, wrap the result in {@link useEventCallback}.\n *\n * @param callback1 - The first callback to be called, or undefined\n * @param callback2 - The second callback to be called, or undefined\n *\n * @returns A function that that calls the provided functions in order\n */\nexport function mergeCallbacks<Args extends unknown[]>(\n  callback1: ((...args: Args) => void) | undefined,\n  callback2: ((...args: Args) => void) | undefined,\n) {\n  return (...args: Args) => {\n    callback1?.(...args);\n    callback2?.(...args);\n  };\n}\n"],"names":["mergeCallbacks","callback1","callback2","args"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,eACdC,SAAgD,EAChDC,SAAgD;IAEhD,OAAO,CAAC,GAAGC;QACTF,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,aAAeE;QACfD,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,aAAeC;IACjB;AACF"}

package/lib-commonjs/utils/omit.js.map

@@ -1 +1 @@
-{"version":3,"sources":["omit.js"],"sourcesContent":["/**\n * Tiny helper to do the minimal amount of work in duplicating an object but omitting some\n * props. This ends up faster than using object ...rest or reduce to filter.\n *\n * This behaves very much like filteredAssign, but does not merge many objects together,\n * uses an exclusion object map, and avoids spreads all for optimal performance.\n *\n * See perf test for background:\n * https://jsperf.com/omit-vs-rest-vs-reduce/1\n *\n * @param obj - The object to clone\n * @param exclusions - The array of keys to exclude\n */ // eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function omit(obj, exclusions) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const result = {};\n    for(const key in obj){\n        if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n"],"names":["omit","obj","exclusions","result","key","indexOf","hasOwnProperty"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAAG,8DAA8D;;;;;+BAClDA;;;eAAAA;;;AAAT,SAASA,KAAKC,GAAG,EAAEC,UAAU;IAChC,8DAA8D;IAC9D,MAAMC,SAAS,CAAC;IAChB,IAAI,MAAMC,OAAOH,IAAI;QACjB,IAAIC,WAAWG,OAAO,CAACD,SAAS,CAAC,KAAKH,IAAIK,cAAc,CAACF,MAAM;YAC3DD,MAAM,CAACC,IAAI,GAAGH,GAAG,CAACG,IAAI;QAC1B;IACJ;IACA,OAAOD;AACX"}
+{"version":3,"sources":["omit.ts"],"sourcesContent":["/**\n * Tiny helper to do the minimal amount of work in duplicating an object but omitting some\n * props. This ends up faster than using object ...rest or reduce to filter.\n *\n * This behaves very much like filteredAssign, but does not merge many objects together,\n * uses an exclusion object map, and avoids spreads all for optimal performance.\n *\n * See perf test for background:\n * https://jsperf.com/omit-vs-rest-vs-reduce/1\n *\n * @param obj - The object to clone\n * @param exclusions - The array of keys to exclude\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(\n  obj: TObj,\n  exclusions: Exclusions,\n): Omit<TObj, Exclusions[number]> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const result: Record<string, any> = {};\n\n  for (const key in obj) {\n    if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {\n      result[key] = obj[key];\n    }\n  }\n\n  return result as TObj;\n}\n"],"names":["omit","obj","exclusions","result","key","indexOf","hasOwnProperty"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;;;;;;;CAYC,GACD,8DAA8D;;;;;+BAC9CA;;;eAAAA;;;AAAT,SAASA,KACdC,GAAS,EACTC,UAAsB;IAEtB,8DAA8D;IAC9D,MAAMC,SAA8B,CAAC;IAErC,IAAK,MAAMC,OAAOH,IAAK;QACrB,IAAIC,WAAWG,OAAO,CAACD,SAAS,CAAC,KAAKH,IAAIK,cAAc,CAACF,MAAM;YAC7DD,MAAM,CAACC,IAAI,GAAGH,GAAG,CAACG,IAAI;QACxB;IACF;IAEA,OAAOD;AACT"}