@fluentui/react-tree 9.7.2 → 9.7.3

package/lib-commonjs/index.js

@@ -9,92 +9,92 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    FlatTree: function() {
+        return _FlatTree.FlatTree;
+    },
+    FlatTreeItem: function() {
+        return _FlatTreeItem.FlatTreeItem;
+    },
     Tree: function() {
         return _Tree.Tree;
     },
-    treeClassNames: function() {
-        return _Tree.treeClassNames;
-    },
-    useTree_unstable: function() {
-        return _Tree.useTree_unstable;
+    TreeItem: function() {
+        return _TreeItem.TreeItem;
     },
-    useTreeStyles_unstable: function() {
-        return _Tree.useTreeStyles_unstable;
+    TreeItemLayout: function() {
+        return _TreeItemLayout.TreeItemLayout;
     },
-    useTreeContextValues_unstable: function() {
-        return _Tree.useTreeContextValues_unstable;
+    TreeItemPersonaLayout: function() {
+        return _TreeItemPersonaLayout.TreeItemPersonaLayout;
     },
-    renderTree_unstable: function() {
-        return _Tree.renderTree_unstable;
+    TreeItemProvider: function() {
+        return _contexts.TreeItemProvider;
     },
-    FlatTree: function() {
-        return _FlatTree.FlatTree;
+    TreeProvider: function() {
+        return _TreeProvider.TreeProvider;
     },
     flatTreeClassNames: function() {
         return _FlatTree.flatTreeClassNames;
     },
-    useFlatTree_unstable: function() {
-        return _FlatTree.useFlatTree_unstable;
-    },
-    useFlatTreeStyles_unstable: function() {
-        return _FlatTree.useFlatTreeStyles_unstable;
-    },
-    useFlatTreeContextValues_unstable: function() {
-        return _FlatTree.useFlatTreeContextValues_unstable;
+    flattenTree_unstable: function() {
+        return _flattenTree.flattenTree_unstable;
     },
     renderFlatTree_unstable: function() {
         return _FlatTree.renderFlatTree_unstable;
     },
-    TreeProvider: function() {
-        return _TreeProvider.TreeProvider;
+    renderTreeItemLayout_unstable: function() {
+        return _TreeItemLayout.renderTreeItemLayout_unstable;
     },
-    useTreeContext_unstable: function() {
-        return _contexts.useTreeContext_unstable;
+    renderTreeItemPersonaLayout_unstable: function() {
+        return _TreeItemPersonaLayout.renderTreeItemPersonaLayout_unstable;
     },
-    useTreeItemContext_unstable: function() {
-        return _contexts.useTreeItemContext_unstable;
+    renderTreeItem_unstable: function() {
+        return _TreeItem.renderTreeItem_unstable;
     },
-    useSubtreeContext_unstable: function() {
-        return _contexts.useSubtreeContext_unstable;
+    renderTree_unstable: function() {
+        return _Tree.renderTree_unstable;
     },
-    TreeItemProvider: function() {
-        return _contexts.TreeItemProvider;
+    treeClassNames: function() {
+        return _Tree.treeClassNames;
+    },
+    treeItemClassNames: function() {
+        return _TreeItem.treeItemClassNames;
+    },
+    treeItemLayoutClassNames: function() {
+        return _TreeItemLayout.treeItemLayoutClassNames;
     },
     treeItemLevelToken: function() {
         return _tokens.treeItemLevelToken;
     },
-    useHeadlessFlatTree_unstable: function() {
-        return _useHeadlessFlatTree.useHeadlessFlatTree_unstable;
-    },
-    TreeItem: function() {
-        return _TreeItem.TreeItem;
+    treeItemPersonaLayoutClassNames: function() {
+        return _TreeItemPersonaLayout.treeItemPersonaLayoutClassNames;
     },
-    treeItemClassNames: function() {
-        return _TreeItem.treeItemClassNames;
+    useFlatTreeContextValues_unstable: function() {
+        return _FlatTree.useFlatTreeContextValues_unstable;
     },
-    renderTreeItem_unstable: function() {
-        return _TreeItem.renderTreeItem_unstable;
+    useFlatTreeStyles_unstable: function() {
+        return _FlatTree.useFlatTreeStyles_unstable;
     },
-    useTreeItemStyles_unstable: function() {
-        return _TreeItem.useTreeItemStyles_unstable;
+    useFlatTree_unstable: function() {
+        return _FlatTree.useFlatTree_unstable;
     },
-    useTreeItemContextValues_unstable: function() {
-        return _TreeItem.useTreeItemContextValues_unstable;
+    useHeadlessFlatTree_unstable: function() {
+        return _useHeadlessFlatTree.useHeadlessFlatTree_unstable;
     },
-    useTreeItem_unstable: function() {
-        return _TreeItem.useTreeItem_unstable;
+    useSubtreeContext_unstable: function() {
+        return _contexts.useSubtreeContext_unstable;
     },
-    FlatTreeItem: function() {
-        return _FlatTreeItem.FlatTreeItem;
+    useTreeContextValues_unstable: function() {
+        return _Tree.useTreeContextValues_unstable;
     },
-    TreeItemLayout: function() {
-        return _TreeItemLayout.TreeItemLayout;
+    useTreeContext_unstable: function() {
+        return _contexts.useTreeContext_unstable;
     },
-    treeItemLayoutClassNames: function() {
-        return _TreeItemLayout.treeItemLayoutClassNames;
+    useTreeItemContextValues_unstable: function() {
+        return _TreeItem.useTreeItemContextValues_unstable;
     },
-    renderTreeItemLayout_unstable: function() {
-        return _TreeItemLayout.renderTreeItemLayout_unstable;
+    useTreeItemContext_unstable: function() {
+        return _contexts.useTreeItemContext_unstable;
     },
     useTreeItemLayoutStyles_unstable: function() {
         return _TreeItemLayout.useTreeItemLayoutStyles_unstable;
@@ -102,23 +102,23 @@ _export(exports, {
     useTreeItemLayout_unstable: function() {
         return _TreeItemLayout.useTreeItemLayout_unstable;
     },
-    TreeItemPersonaLayout: function() {
-        return _TreeItemPersonaLayout.TreeItemPersonaLayout;
-    },
-    treeItemPersonaLayoutClassNames: function() {
-        return _TreeItemPersonaLayout.treeItemPersonaLayoutClassNames;
-    },
-    renderTreeItemPersonaLayout_unstable: function() {
-        return _TreeItemPersonaLayout.renderTreeItemPersonaLayout_unstable;
-    },
     useTreeItemPersonaLayoutStyles_unstable: function() {
         return _TreeItemPersonaLayout.useTreeItemPersonaLayoutStyles_unstable;
     },
     useTreeItemPersonaLayout_unstable: function() {
         return _TreeItemPersonaLayout.useTreeItemPersonaLayout_unstable;
     },
-    flattenTree_unstable: function() {
-        return _flattenTree.flattenTree_unstable;
+    useTreeItemStyles_unstable: function() {
+        return _TreeItem.useTreeItemStyles_unstable;
+    },
+    useTreeItem_unstable: function() {
+        return _TreeItem.useTreeItem_unstable;
+    },
+    useTreeStyles_unstable: function() {
+        return _Tree.useTreeStyles_unstable;
+    },
+    useTree_unstable: function() {
+        return _Tree.useTree_unstable;
     }
 });
 const _Tree = require("./Tree");

package/lib-commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export { Tree, treeClassNames, useTree_unstable, useTreeStyles_unstable, useTreeContextValues_unstable, renderTree_unstable } from './Tree';\nexport { FlatTree, flatTreeClassNames, useFlatTree_unstable, useFlatTreeStyles_unstable, useFlatTreeContextValues_unstable, renderFlatTree_unstable } from './FlatTree';\nexport { TreeProvider } from './components/TreeProvider';\nexport { useTreeContext_unstable, useTreeItemContext_unstable, useSubtreeContext_unstable, TreeItemProvider } from './contexts';\nexport { treeItemLevelToken } from './utils/tokens';\nexport { useHeadlessFlatTree_unstable } from './components/FlatTree/useHeadlessFlatTree';\nexport { TreeItem, treeItemClassNames, renderTreeItem_unstable, useTreeItemStyles_unstable, useTreeItemContextValues_unstable, useTreeItem_unstable } from './TreeItem';\nexport { FlatTreeItem } from './FlatTreeItem';\nexport { TreeItemLayout, treeItemLayoutClassNames, renderTreeItemLayout_unstable, useTreeItemLayoutStyles_unstable, useTreeItemLayout_unstable } from './TreeItemLayout';\nexport { TreeItemPersonaLayout, treeItemPersonaLayoutClassNames, renderTreeItemPersonaLayout_unstable, useTreeItemPersonaLayoutStyles_unstable, useTreeItemPersonaLayout_unstable } from './TreeItemPersonaLayout';\nexport { flattenTree_unstable } from './utils/flattenTree';\n"],"names":["Tree","treeClassNames","useTree_unstable","useTreeStyles_unstable","useTreeContextValues_unstable","renderTree_unstable","FlatTree","flatTreeClassNames","useFlatTree_unstable","useFlatTreeStyles_unstable","useFlatTreeContextValues_unstable","renderFlatTree_unstable","TreeProvider","useTreeContext_unstable","useTreeItemContext_unstable","useSubtreeContext_unstable","TreeItemProvider","treeItemLevelToken","useHeadlessFlatTree_unstable","TreeItem","treeItemClassNames","renderTreeItem_unstable","useTreeItemStyles_unstable","useTreeItemContextValues_unstable","useTreeItem_unstable","FlatTreeItem","TreeItemLayout","treeItemLayoutClassNames","renderTreeItemLayout_unstable","useTreeItemLayoutStyles_unstable","useTreeItemLayout_unstable","TreeItemPersonaLayout","treeItemPersonaLayoutClassNames","renderTreeItemPersonaLayout_unstable","useTreeItemPersonaLayoutStyles_unstable","useTreeItemPersonaLayout_unstable","flattenTree_unstable"],"mappings":";;;;;;;;;;;IAASA,IAAI;eAAJA,UAAI;;IAAEC,cAAc;eAAdA,oBAAc;;IAAEC,gBAAgB;eAAhBA,sBAAgB;;IAAEC,sBAAsB;eAAtBA,4BAAsB;;IAAEC,6BAA6B;eAA7BA,mCAA6B;;IAAEC,mBAAmB;eAAnBA,yBAAmB;;IAClHC,QAAQ;eAARA,kBAAQ;;IAAEC,kBAAkB;eAAlBA,4BAAkB;;IAAEC,oBAAoB;eAApBA,8BAAoB;;IAAEC,0BAA0B;eAA1BA,oCAA0B;;IAAEC,iCAAiC;eAAjCA,2CAAiC;;IAAEC,uBAAuB;eAAvBA,iCAAuB;;IAC1IC,YAAY;eAAZA,0BAAY;;IACZC,uBAAuB;eAAvBA,iCAAuB;;IAAEC,2BAA2B;eAA3BA,qCAA2B;;IAAEC,0BAA0B;eAA1BA,oCAA0B;;IAAEC,gBAAgB;eAAhBA,0BAAgB;;IAClGC,kBAAkB;eAAlBA,0BAAkB;;IAClBC,4BAA4B;eAA5BA,iDAA4B;;IAC5BC,QAAQ;eAARA,kBAAQ;;IAAEC,kBAAkB;eAAlBA,4BAAkB;;IAAEC,uBAAuB;eAAvBA,iCAAuB;;IAAEC,0BAA0B;eAA1BA,oCAA0B;;IAAEC,iCAAiC;eAAjCA,2CAAiC;;IAAEC,oBAAoB;eAApBA,8BAAoB;;IAC1IC,YAAY;eAAZA,0BAAY;;IACZC,cAAc;eAAdA,8BAAc;;IAAEC,wBAAwB;eAAxBA,wCAAwB;;IAAEC,6BAA6B;eAA7BA,6CAA6B;;IAAEC,gCAAgC;eAAhCA,gDAAgC;;IAAEC,0BAA0B;eAA1BA,0CAA0B;;IACrIC,qBAAqB;eAArBA,4CAAqB;;IAAEC,+BAA+B;eAA/BA,sDAA+B;;IAAEC,oCAAoC;eAApCA,2DAAoC;;IAAEC,uCAAuC;eAAvCA,8DAAuC;;IAAEC,iCAAiC;eAAjCA,wDAAiC;;IACxKC,oBAAoB;eAApBA,iCAAoB;;;sBAVsG;0BACwB;8BAC9H;0BACsF;wBAChF;qCACU;0BAC8G;8BAC9H;gCACyH;uCACmC;6BACpJ"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  Tree,\n  treeClassNames,\n  useTree_unstable,\n  useTreeStyles_unstable,\n  useTreeContextValues_unstable,\n  renderTree_unstable,\n} from './Tree';\n\nexport type {\n  TreeSlots,\n  TreeProps,\n  TreeState,\n  TreeContextValues,\n  TreeOpenChangeData,\n  TreeSelectionValue,\n  TreeOpenChangeEvent,\n  TreeCheckedChangeData,\n  TreeCheckedChangeEvent,\n  TreeNavigationData_unstable,\n  TreeNavigationEvent_unstable,\n} from './Tree';\n\nexport {\n  FlatTree,\n  flatTreeClassNames,\n  useFlatTree_unstable,\n  useFlatTreeStyles_unstable,\n  useFlatTreeContextValues_unstable,\n  renderFlatTree_unstable,\n} from './FlatTree';\n\nexport type { FlatTreeSlots, FlatTreeProps, FlatTreeState } from './FlatTree';\n\nexport { TreeProvider } from './components/TreeProvider';\n\nexport {\n  useTreeContext_unstable,\n  useTreeItemContext_unstable,\n  useSubtreeContext_unstable,\n  TreeItemProvider,\n} from './contexts';\nexport type { TreeContextValue, SubtreeContextValue, TreeItemContextValue } from './contexts';\n\nexport { treeItemLevelToken } from './utils/tokens';\n\nexport { useHeadlessFlatTree_unstable } from './components/FlatTree/useHeadlessFlatTree';\nexport type {\n  HeadlessFlatTree,\n  HeadlessFlatTreeItem,\n  HeadlessFlatTreeItemProps,\n  HeadlessFlatTreeOptions,\n} from './components/FlatTree/useHeadlessFlatTree';\n\nexport {\n  TreeItem,\n  treeItemClassNames,\n  renderTreeItem_unstable,\n  useTreeItemStyles_unstable,\n  useTreeItemContextValues_unstable,\n  useTreeItem_unstable,\n} from './TreeItem';\nexport type {\n  TreeItemProps,\n  TreeItemState,\n  TreeItemSlots,\n  TreeItemType,\n  TreeItemValue,\n  TreeItemOpenChangeData,\n  TreeItemOpenChangeEvent,\n} from './TreeItem';\n\nexport { FlatTreeItem } from './FlatTreeItem';\nexport type { FlatTreeItemProps } from './FlatTreeItem';\n\nexport {\n  TreeItemLayout,\n  treeItemLayoutClassNames,\n  renderTreeItemLayout_unstable,\n  useTreeItemLayoutStyles_unstable,\n  useTreeItemLayout_unstable,\n} from './TreeItemLayout';\nexport type { TreeItemLayoutProps, TreeItemLayoutSlots, TreeItemLayoutState } from './TreeItemLayout';\n\nexport {\n  TreeItemPersonaLayout,\n  treeItemPersonaLayoutClassNames,\n  renderTreeItemPersonaLayout_unstable,\n  useTreeItemPersonaLayoutStyles_unstable,\n  useTreeItemPersonaLayout_unstable,\n} from './TreeItemPersonaLayout';\nexport type {\n  TreeItemPersonaLayoutProps,\n  TreeItemPersonaLayoutSlots,\n  TreeItemPersonaLayoutState,\n} from './TreeItemPersonaLayout';\n\nexport { flattenTree_unstable } from './utils/flattenTree';\nexport type { FlattenTreeItem } from './utils/flattenTree';\n"],"names":["FlatTree","FlatTreeItem","Tree","TreeItem","TreeItemLayout","TreeItemPersonaLayout","TreeItemProvider","TreeProvider","flatTreeClassNames","flattenTree_unstable","renderFlatTree_unstable","renderTreeItemLayout_unstable","renderTreeItemPersonaLayout_unstable","renderTreeItem_unstable","renderTree_unstable","treeClassNames","treeItemClassNames","treeItemLayoutClassNames","treeItemLevelToken","treeItemPersonaLayoutClassNames","useFlatTreeContextValues_unstable","useFlatTreeStyles_unstable","useFlatTree_unstable","useHeadlessFlatTree_unstable","useSubtreeContext_unstable","useTreeContextValues_unstable","useTreeContext_unstable","useTreeItemContextValues_unstable","useTreeItemContext_unstable","useTreeItemLayoutStyles_unstable","useTreeItemLayout_unstable","useTreeItemPersonaLayoutStyles_unstable","useTreeItemPersonaLayout_unstable","useTreeItemStyles_unstable","useTreeItem_unstable","useTreeStyles_unstable","useTree_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAwBEA,QAAQ;eAARA,kBAAQ;;IAgDDC,YAAY;eAAZA,0BAAY;;IAvEnBC,IAAI;eAAJA,UAAI;;IAsDJC,QAAQ;eAARA,kBAAQ;;IAqBRC,cAAc;eAAdA,8BAAc;;IASdC,qBAAqB;eAArBA,4CAAqB;;IA7CrBC,gBAAgB;eAAhBA,0BAAgB;;IANTC,YAAY;eAAZA,0BAAY;;IATnBC,kBAAkB;eAAlBA,4BAAkB;;IAwEXC,oBAAoB;eAApBA,iCAAoB;;IApE3BC,uBAAuB;eAAvBA,iCAAuB;;IAiDvBC,6BAA6B;eAA7BA,6CAA6B;;IAS7BC,oCAAoC;eAApCA,2DAAoC;;IA9BpCC,uBAAuB;eAAvBA,iCAAuB;;IAnDvBC,mBAAmB;eAAnBA,yBAAmB;;IAJnBC,cAAc;eAAdA,oBAAc;;IAsDdC,kBAAkB;eAAlBA,4BAAkB;;IAqBlBC,wBAAwB;eAAxBA,wCAAwB;;IAjCjBC,kBAAkB;eAAlBA,0BAAkB;;IA0CzBC,+BAA+B;eAA/BA,sDAA+B;;IA1D/BC,iCAAiC;eAAjCA,2CAAiC;;IADjCC,0BAA0B;eAA1BA,oCAA0B;;IAD1BC,oBAAoB;eAApBA,8BAAoB;;IAoBbC,4BAA4B;eAA5BA,iDAA4B;;IAPnCC,0BAA0B;eAA1BA,oCAA0B;;IAlC1BC,6BAA6B;eAA7BA,mCAA6B;;IAgC7BC,uBAAuB;eAAvBA,iCAAuB;;IAsBvBC,iCAAiC;eAAjCA,2CAAiC;;IArBjCC,2BAA2B;eAA3BA,qCAA2B;;IAyC3BC,gCAAgC;eAAhCA,gDAAgC;;IAChCC,0BAA0B;eAA1BA,0CAA0B;;IAQ1BC,uCAAuC;eAAvCA,8DAAuC;;IACvCC,iCAAiC;eAAjCA,wDAAiC;;IA/BjCC,0BAA0B;eAA1BA,oCAA0B;;IAE1BC,oBAAoB;eAApBA,8BAAoB;;IAxDpBC,sBAAsB;eAAtBA,4BAAsB;;IADtBC,gBAAgB;eAAhBA,sBAAgB;;;sBAIX;0BAuBA;8BAIsB;0BAOtB;wBAG4B;qCAEU;0BAetC;8BAWsB;gCAStB;uCASA;6BAO8B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["ImmutableMap.js"],"sourcesContent":["const emptyImmutableMap = createImmutableMap();\n/**\n * properly creates an ImmutableMap instance from an iterable\n */ function createImmutableMap(iterable) {\n    const internalMap = new Map(iterable);\n    return dangerouslyCreateImmutableMap(internalMap);\n}\n/**\n * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,\n * @param internalMap - a set that is used internally to store values.\n */ function dangerouslyCreateImmutableMap(internalMap) {\n    return {\n        size: internalMap.size,\n        set: (key, value)=>{\n            const nextSet = new Map(internalMap);\n            nextSet.set(key, value);\n            return dangerouslyCreateImmutableMap(nextSet);\n        },\n        get: (key)=>internalMap.get(key),\n        clear: ()=>emptyImmutableMap,\n        delete (value) {\n            const nextSet = new Map(internalMap);\n            nextSet.delete(value);\n            return dangerouslyCreateImmutableMap(nextSet);\n        },\n        has: (value)=>internalMap.has(value),\n        [Symbol.iterator]: ()=>internalMap[Symbol.iterator](),\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        dangerouslyGetInternalMap_unstable: ()=>internalMap\n    };\n}\nfunction isImmutableMap(value) {\n    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;\n}\nexport const ImmutableMap = {\n    empty: emptyImmutableMap,\n    create: createImmutableMap,\n    isImmutableMap,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyCreate_unstable: dangerouslyCreateImmutableMap\n};\n"],"names":["ImmutableMap","emptyImmutableMap","createImmutableMap","iterable","internalMap","Map","dangerouslyCreateImmutableMap","size","set","key","value","nextSet","get","clear","delete","has","Symbol","iterator","dangerouslyGetInternalMap_unstable","isImmutableMap","empty","create","dangerouslyCreate_unstable"],"mappings":";;;;+BAkCaA;;;eAAAA;;;AAlCb,MAAMC,oBAAoBC;AAC1B;;CAEC,GAAG,SAASA,mBAAmBC,QAAQ;IACpC,MAAMC,cAAc,IAAIC,IAAIF;IAC5B,OAAOG,8BAA8BF;AACzC;AACA;;;CAGC,GAAG,SAASE,8BAA8BF,WAAW;IAClD,OAAO;QACHG,MAAMH,YAAYG,IAAI;QACtBC,KAAK,CAACC,KAAKC;YACP,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQH,GAAG,CAACC,KAAKC;YACjB,OAAOJ,8BAA8BK;QACzC;QACAC,KAAK,CAACH,MAAML,YAAYQ,GAAG,CAACH;QAC5BI,OAAO,IAAIZ;QACXa,QAAQJ,KAAK;YACT,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACzC;QACAI,KAAK,CAACL,QAAQN,YAAYW,GAAG,CAACL;QAC9B,CAACM,OAAOC,QAAQ,CAAC,EAAE,IAAIb,WAAW,CAACY,OAAOC,QAAQ,CAAC;QACnD,gEAAgE;QAChEC,oCAAoC,IAAId;IAC5C;AACJ;AACA,SAASe,eAAeT,KAAK;IACzB,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAClG;AACO,MAAMV,eAAe;IACxBoB,OAAOnB;IACPoB,QAAQnB;IACRiB;IACA,gEAAgE;IAChEG,4BAA4BhB;AAChC"}
+{"version":3,"sources":["ImmutableMap.ts"],"sourcesContent":["export interface ImmutableMap<Key, Value> {\n  clear(): ImmutableMap<Key, Value>;\n  delete(key: Key): ImmutableMap<Key, Value>;\n  /**\n   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.\n   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.\n   */\n  get(key: Key): Value | undefined;\n  /**\n   * @returns boolean indicating whether an element with the specified key exists or not.\n   */\n  has(key: Key): boolean;\n  /**\n   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.\n   */\n  set(key: Key, value: Value): ImmutableMap<Key, Value>;\n  /**\n   * @returns the number of elements in the Map.\n   */\n  readonly size: number;\n  /** Iterates over entries in the Map. */\n  [Symbol.iterator](): IterableIterator<[Key, Value]>;\n  /**\n   * @internal\n   * Exposes the internal map used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyGetInternalMap_unstable(): Map<Key, Value>;\n}\n\nconst emptyImmutableMap = createImmutableMap<never, never>();\n\n/**\n * properly creates an ImmutableMap instance from an iterable\n */\nfunction createImmutableMap<Key, Value>(iterable?: Iterable<[Key, Value]>): ImmutableMap<Key, Value> {\n  const internalMap = new Map(iterable);\n  return dangerouslyCreateImmutableMap(internalMap);\n}\n/**\n * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,\n * @param internalMap - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableMap<Key, Value>(internalMap: Map<Key, Value>): ImmutableMap<Key, Value> {\n  return {\n    size: internalMap.size,\n    set: (key, value) => {\n      const nextSet = new Map(internalMap);\n      nextSet.set(key, value);\n      return dangerouslyCreateImmutableMap(nextSet);\n    },\n    get: key => internalMap.get(key),\n    clear: () => emptyImmutableMap,\n    delete(value) {\n      const nextSet = new Map(internalMap);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableMap(nextSet);\n    },\n    has: value => internalMap.has(value),\n    [Symbol.iterator]: () => internalMap[Symbol.iterator](),\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyGetInternalMap_unstable: () => internalMap,\n  };\n}\n\nfunction isImmutableMap<Key, Value>(value: unknown): value is ImmutableMap<Key, Value> {\n  return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;\n}\n\nexport const ImmutableMap = {\n  empty: emptyImmutableMap,\n  create: createImmutableMap,\n  isImmutableMap,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyCreate_unstable: dangerouslyCreateImmutableMap,\n};\n"],"names":["ImmutableMap","emptyImmutableMap","createImmutableMap","iterable","internalMap","Map","dangerouslyCreateImmutableMap","size","set","key","value","nextSet","get","clear","delete","has","Symbol","iterator","dangerouslyGetInternalMap_unstable","isImmutableMap","empty","create","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAsEaA;;;eAAAA;;;AAvCb,MAAMC,oBAAoBC;AAE1B;;CAEC,GACD,SAASA,mBAA+BC,QAAiC;IACvE,MAAMC,cAAc,IAAIC,IAAIF;IAC5B,OAAOG,8BAA8BF;AACvC;AACA;;;CAGC,GACD,SAASE,8BAA0CF,WAA4B;IAC7E,OAAO;QACLG,MAAMH,YAAYG,IAAI;QACtBC,KAAK,CAACC,KAAKC;YACT,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQH,GAAG,CAACC,KAAKC;YACjB,OAAOJ,8BAA8BK;QACvC;QACAC,KAAKH,CAAAA,MAAOL,YAAYQ,GAAG,CAACH;QAC5BI,OAAO,IAAMZ;QACba,QAAOJ,KAAK;YACV,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAKL,CAAAA,QAASN,YAAYW,GAAG,CAACL;QAC9B,CAACM,OAAOC,QAAQ,CAAC,EAAE,IAAMb,WAAW,CAACY,OAAOC,QAAQ,CAAC;QACrD,gEAAgE;QAChEC,oCAAoC,IAAMd;IAC5C;AACF;AAEA,SAASe,eAA2BT,KAAc;IAChD,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAChG;AAEO,MAAMV,eAAe;IAC1BoB,OAAOnB;IACPoB,QAAQnB;IACRiB;IACA,gEAAgE;IAChEG,4BAA4BhB;AAC9B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["ImmutableSet.js"],"sourcesContent":["const emptyImmutableSet = createImmutableSet();\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */ function dangerouslyCreateImmutableSet(internalSet) {\n    return {\n        size: internalSet.size,\n        add (value) {\n            const nextSet = new Set(internalSet);\n            nextSet.add(value);\n            return dangerouslyCreateImmutableSet(nextSet);\n        },\n        clear () {\n            return emptyImmutableSet;\n        },\n        delete (value) {\n            const nextSet = new Set(internalSet);\n            nextSet.delete(value);\n            return dangerouslyCreateImmutableSet(nextSet);\n        },\n        has (value) {\n            return internalSet.has(value);\n        },\n        [Symbol.iterator] () {\n            return internalSet[Symbol.iterator]();\n        },\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        dangerouslyGetInternalSet_unstable: ()=>internalSet\n    };\n}\nfunction isImmutableSet(value) {\n    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;\n}\n/**\n * properly creates an ImmutableSet instance from an iterable\n */ function createImmutableSet(iterable) {\n    const internalSet = new Set(iterable);\n    return dangerouslyCreateImmutableSet(internalSet);\n}\nexport const ImmutableSet = {\n    empty: emptyImmutableSet,\n    create: createImmutableSet,\n    isImmutableSet,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyCreate_unstable: dangerouslyCreateImmutableSet\n};\n"],"names":["ImmutableSet","emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerouslyGetInternalSet_unstable","isImmutableSet","iterable","empty","create","dangerouslyCreate_unstable"],"mappings":";;;;+BAuCaA;;;eAAAA;;;AAvCb,MAAMC,oBAAoBC;AAC1B;;;CAGC,GAAG,SAASC,8BAA8BC,WAAW;IAClD,OAAO;QACHC,MAAMD,YAAYC,IAAI;QACtBC,KAAKC,KAAK;YACN,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACzC;QACAE;YACI,OAAOT;QACX;QACAU,QAAQJ,KAAK;YACT,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACzC;QACAI,KAAKL,KAAK;YACN,OAAOH,YAAYQ,GAAG,CAACL;QAC3B;QACA,CAACM,OAAOC,QAAQ,CAAC;YACb,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACvC;QACA,gEAAgE;QAChEC,oCAAoC,IAAIX;IAC5C;AACJ;AACA,SAASY,eAAeT,KAAK;IACzB,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAClG;AACA;;CAEC,GAAG,SAASL,mBAAmBe,QAAQ;IACpC,MAAMb,cAAc,IAAIK,IAAIQ;IAC5B,OAAOd,8BAA8BC;AACzC;AACO,MAAMJ,eAAe;IACxBkB,OAAOjB;IACPkB,QAAQjB;IACRc;IACA,gEAAgE;IAChEI,4BAA4BjB;AAChC"}
+{"version":3,"sources":["ImmutableSet.ts"],"sourcesContent":["export interface ImmutableSet<Value> {\n  /**\n   * The number of (unique) elements in a ImmutableSet.\n   */\n  readonly size: number;\n  /**\n   * Creates a new ImmutableSet containing all previous element plus the one provided as argument\n   * @param value - new value to be included in the new ImmutableSet instance\n   */\n  add(value: Value): ImmutableSet<Value>;\n  /**\n   * Returns a reference to ImmutableSet.emptySet\n   */\n  clear(): ImmutableSet<Value>;\n  /**\n   * Creates a new ImmutableSet with the original items and removes a specified value from the new ImmutableSet.\n   */\n  delete(value: Value): ImmutableSet<Value>;\n  /**\n   * @returns a boolean indicating whether an element with the specified value exists in the ImmutableSet or not.\n   */\n  has(value: Value): boolean;\n  /** Iterates over values in the ImmutableSet. */\n  [Symbol.iterator](): IterableIterator<Value>;\n  /**\n   * @internal\n   * Exposes the internal set used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyGetInternalSet_unstable(): Set<Value>;\n}\n\nconst emptyImmutableSet = createImmutableSet<never>();\n\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableSet<Value>(internalSet: Set<Value>): ImmutableSet<Value> {\n  return {\n    size: internalSet.size,\n    add(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.add(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    clear() {\n      return emptyImmutableSet;\n    },\n    delete(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    has(value) {\n      return internalSet.has(value);\n    },\n    [Symbol.iterator]() {\n      return internalSet[Symbol.iterator]();\n    },\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyGetInternalSet_unstable: () => internalSet,\n  };\n}\n\nfunction isImmutableSet<Value>(value: unknown): value is ImmutableSet<Value> {\n  return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;\n}\n\n/**\n * properly creates an ImmutableSet instance from an iterable\n */\nfunction createImmutableSet<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n  const internalSet = new Set(iterable);\n  return dangerouslyCreateImmutableSet(internalSet);\n}\n\nexport const ImmutableSet = {\n  empty: emptyImmutableSet,\n  create: createImmutableSet,\n  isImmutableSet,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyCreate_unstable: dangerouslyCreateImmutableSet,\n};\n"],"names":["ImmutableSet","emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerouslyGetInternalSet_unstable","isImmutableSet","iterable","empty","create","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA8EaA;;;eAAAA;;;AA7Cb,MAAMC,oBAAoBC;AAE1B;;;CAGC,GACD,SAASC,8BAAqCC,WAAuB;IACnE,OAAO;QACLC,MAAMD,YAAYC,IAAI;QACtBC,KAAIC,KAAK;YACP,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACvC;QACAE;YACE,OAAOT;QACT;QACAU,QAAOJ,KAAK;YACV,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAIL,KAAK;YACP,OAAOH,YAAYQ,GAAG,CAACL;QACzB;QACA,CAACM,OAAOC,QAAQ,CAAC;YACf,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACrC;QACA,gEAAgE;QAChEC,oCAAoC,IAAMX;IAC5C;AACF;AAEA,SAASY,eAAsBT,KAAc;IAC3C,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAChG;AAEA;;CAEC,GACD,SAASL,mBAA0Be,QAA0B;IAC3D,MAAMb,cAAc,IAAIK,IAAIQ;IAC5B,OAAOd,8BAA8BC;AACvC;AAEO,MAAMJ,eAAe;IAC1BkB,OAAOjB;IACPkB,QAAQjB;IACRc;IACA,gEAAgE;IAChEI,4BAA4BjB;AAC9B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["assert.js"],"sourcesContent":["import * as React from 'react';\nexport function assertIsDefinedRef(refObject, msg = `assertIsDefinedRef: reference not properly defined ${refObject}`) {\n    // eslint-disable-next-line eqeqeq\n    if (refObject.current == undefined && process.env.NODE_ENV === 'development') {\n        throw new TypeError(msg);\n    }\n}\n"],"names":["assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError"],"mappings":";;;;+BACgBA;;;eAAAA;;;;iEADO;AAChB,SAASA,mBAAmBC,SAAS,EAAEC,MAAM,CAAC,mDAAmD,EAAED,UAAU,CAAC;IACjH,kCAAkC;IAClC,IAAIA,UAAUE,OAAO,IAAIC,aAAaC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1E,MAAM,IAAIC,UAAUN;IACxB;AACJ"}
+{"version":3,"sources":["assert.ts"],"sourcesContent":["import * as React from 'react';\n\nexport function assertIsDefinedRef<V>(\n  refObject: React.RefObject<V | null | undefined>,\n  msg = `assertIsDefinedRef: reference not properly defined ${refObject}`,\n): asserts refObject is React.MutableRefObject<V> {\n  // eslint-disable-next-line eqeqeq\n  if (refObject.current == undefined && process.env.NODE_ENV === 'development') {\n    throw new TypeError(msg);\n  }\n}\n"],"names":["assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BAEgBA;;;eAAAA;;;;iEAFO;AAEhB,SAASA,mBACdC,SAAgD,EAChDC,MAAM,CAAC,mDAAmD,EAAED,UAAU,CAAC;IAEvE,kCAAkC;IAClC,IAAIA,UAAUE,OAAO,IAAIC,aAAaC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC5E,MAAM,IAAIC,UAAUN;IACtB;AACF"}

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

@@ -1 +1 @@
-{"version":3,"sources":["createCheckedItems.js"],"sourcesContent":["import { ImmutableMap } from './ImmutableMap';\nexport function createCheckedItems(iterable) {\n    if (iterable === undefined) {\n        return ImmutableMap.empty;\n    }\n    if (ImmutableMap.isImmutableMap(iterable)) {\n        return iterable;\n    }\n    const internalMap = new Map();\n    for (const item of iterable){\n        if (Array.isArray(item)) {\n            internalMap.set(item[0], item[1]);\n        } else {\n            internalMap.set(item, true);\n        }\n    }\n    return ImmutableMap.dangerouslyCreate_unstable(internalMap);\n}\n"],"names":["createCheckedItems","iterable","undefined","ImmutableMap","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"mappings":";;;;+BACgBA;;;eAAAA;;;8BADa;AACtB,SAASA,mBAAmBC,QAAQ;IACvC,IAAIA,aAAaC,WAAW;QACxB,OAAOC,0BAAY,CAACC,KAAK;IAC7B;IACA,IAAID,0BAAY,CAACE,cAAc,CAACJ,WAAW;QACvC,OAAOA;IACX;IACA,MAAMK,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQP,SAAS;QACxB,IAAIQ,MAAMC,OAAO,CAACF,OAAO;YACrBF,YAAYK,GAAG,CAACH,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QACpC,OAAO;YACHF,YAAYK,GAAG,CAACH,MAAM;QAC1B;IACJ;IACA,OAAOL,0BAAY,CAACS,0BAA0B,CAACN;AACnD"}
+{"version":3,"sources":["createCheckedItems.ts"],"sourcesContent":["import { ImmutableMap } from './ImmutableMap';\nimport type { TreeSelectionValue } from '../Tree';\nimport type { TreeItemValue } from '../TreeItem';\n\nexport function createCheckedItems(iterable?: Iterable<TreeItemValue | [TreeItemValue, TreeSelectionValue]>) {\n  if (iterable === undefined) {\n    return ImmutableMap.empty;\n  }\n  if (ImmutableMap.isImmutableMap<TreeItemValue, TreeSelectionValue>(iterable)) {\n    return iterable;\n  }\n  const internalMap = new Map<TreeItemValue, 'mixed' | boolean>();\n  for (const item of iterable) {\n    if (Array.isArray(item)) {\n      internalMap.set(item[0], item[1]);\n    } else {\n      internalMap.set(item, true);\n    }\n  }\n  return ImmutableMap.dangerouslyCreate_unstable(internalMap);\n}\n"],"names":["createCheckedItems","iterable","undefined","ImmutableMap","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIgBA;;;eAAAA;;;8BAJa;AAItB,SAASA,mBAAmBC,QAAwE;IACzG,IAAIA,aAAaC,WAAW;QAC1B,OAAOC,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAID,0BAAAA,CAAaE,cAAc,CAAoCJ,WAAW;QAC5E,OAAOA;IACT;IACA,MAAMK,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQP,SAAU;QAC3B,IAAIQ,MAAMC,OAAO,CAACF,OAAO;YACvBF,YAAYK,GAAG,CAACH,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QAClC,OAAO;YACLF,YAAYK,GAAG,CAACH,MAAM;QACxB;IACF;IACA,OAAOL,0BAAAA,CAAaS,0BAA0B,CAACN;AACjD"}

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

@@ -1 +1 @@
-{"version":3,"sources":["createHTMLElementWalker.js"],"sourcesContent":["import { isHTMLElement } from '@fluentui/react-utilities';\nexport function createHTMLElementWalker(root, targetDocument, filter = ()=>NodeFilter.FILTER_ACCEPT) {\n    let temporaryFilter;\n    const treeWalker = targetDocument.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {\n        acceptNode (node) {\n            if (!isHTMLElement(node)) {\n                return NodeFilter.FILTER_REJECT;\n            }\n            const filterResult = filter(node);\n            var _temporaryFilter;\n            return filterResult === NodeFilter.FILTER_ACCEPT ? (_temporaryFilter = temporaryFilter === null || temporaryFilter === void 0 ? void 0 : temporaryFilter(node)) !== null && _temporaryFilter !== void 0 ? _temporaryFilter : filterResult : filterResult;\n        }\n    });\n    return {\n        get root () {\n            return treeWalker.root;\n        },\n        get currentElement () {\n            return treeWalker.currentNode;\n        },\n        set currentElement (element){\n            treeWalker.currentNode = element;\n        },\n        firstChild: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.firstChild();\n            temporaryFilter = undefined;\n            return result;\n        },\n        lastChild: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.lastChild();\n            temporaryFilter = undefined;\n            return result;\n        },\n        nextElement: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.nextNode();\n            temporaryFilter = undefined;\n            return result;\n        },\n        nextSibling: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.nextSibling();\n            temporaryFilter = undefined;\n            return result;\n        },\n        parentElement: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.parentNode();\n            temporaryFilter = undefined;\n            return result;\n        },\n        previousElement: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.previousNode();\n            temporaryFilter = undefined;\n            return result;\n        },\n        previousSibling: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.previousSibling();\n            temporaryFilter = undefined;\n            return result;\n        }\n    };\n}\n"],"names":["createHTMLElementWalker","root","targetDocument","filter","NodeFilter","FILTER_ACCEPT","temporaryFilter","treeWalker","createTreeWalker","SHOW_ELEMENT","acceptNode","node","isHTMLElement","FILTER_REJECT","filterResult","_temporaryFilter","currentElement","currentNode","element","firstChild","localFilter","result","undefined","lastChild","nextElement","nextNode","nextSibling","parentElement","parentNode","previousElement","previousNode","previousSibling"],"mappings":";;;;+BACgBA;;;eAAAA;;;gCADc;AACvB,SAASA,wBAAwBC,IAAI,EAAEC,cAAc,EAAEC,SAAS,IAAIC,WAAWC,aAAa;IAC/F,IAAIC;IACJ,MAAMC,aAAaL,eAAeM,gBAAgB,CAACP,MAAMG,WAAWK,YAAY,EAAE;QAC9EC,YAAYC,IAAI;YACZ,IAAI,CAACC,IAAAA,6BAAa,EAACD,OAAO;gBACtB,OAAOP,WAAWS,aAAa;YACnC;YACA,MAAMC,eAAeX,OAAOQ;YAC5B,IAAII;YACJ,OAAOD,iBAAiBV,WAAWC,aAAa,GAAG,AAACU,CAAAA,mBAAmBT,oBAAoB,QAAQA,oBAAoB,KAAK,IAAI,KAAK,IAAIA,gBAAgBK,KAAI,MAAO,QAAQI,qBAAqB,KAAK,IAAIA,mBAAmBD,eAAeA;QAChP;IACJ;IACA,OAAO;QACH,IAAIb,QAAQ;YACR,OAAOM,WAAWN,IAAI;QAC1B;QACA,IAAIe,kBAAkB;YAClB,OAAOT,WAAWU,WAAW;QACjC;QACA,IAAID,gBAAgBE,QAAQ;YACxBX,WAAWU,WAAW,GAAGC;QAC7B;QACAC,YAAY,CAACC;YACTd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWY,UAAU;YACpCb,kBAAkBgB;YAClB,OAAOD;QACX;QACAE,WAAW,CAACH;YACRd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWgB,SAAS;YACnCjB,kBAAkBgB;YAClB,OAAOD;QACX;QACAG,aAAa,CAACJ;YACVd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWkB,QAAQ;YAClCnB,kBAAkBgB;YAClB,OAAOD;QACX;QACAK,aAAa,CAACN;YACVd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWmB,WAAW;YACrCpB,kBAAkBgB;YAClB,OAAOD;QACX;QACAM,eAAe,CAACP;YACZd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWqB,UAAU;YACpCtB,kBAAkBgB;YAClB,OAAOD;QACX;QACAQ,iBAAiB,CAACT;YACdd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWuB,YAAY;YACtCxB,kBAAkBgB;YAClB,OAAOD;QACX;QACAU,iBAAiB,CAACX;YACdd,kBAAkBc;YAClB,MAAMC,SAASd,WAAWwB,eAAe;YACzCzB,kBAAkBgB;YAClB,OAAOD;QACX;IACJ;AACJ"}
+{"version":3,"sources":["createHTMLElementWalker.ts"],"sourcesContent":["import { isHTMLElement } from '@fluentui/react-utilities';\n\nexport interface HTMLElementWalker {\n  readonly root: HTMLElement;\n  currentElement: HTMLElement;\n  firstChild(filter?: HTMLElementFilter): HTMLElement | null;\n  lastChild(filter?: HTMLElementFilter): HTMLElement | null;\n  nextElement(filter?: HTMLElementFilter): HTMLElement | null;\n  nextSibling(filter?: HTMLElementFilter): HTMLElement | null;\n  parentElement(filter?: HTMLElementFilter): HTMLElement | null;\n  previousElement(filter?: HTMLElementFilter): HTMLElement | null;\n  previousSibling(filter?: HTMLElementFilter): HTMLElement | null;\n}\n\nexport type HTMLElementFilter = (element: HTMLElement) => number;\n\nexport function createHTMLElementWalker(\n  root: HTMLElement,\n  targetDocument: Document,\n  filter: HTMLElementFilter = () => NodeFilter.FILTER_ACCEPT,\n): HTMLElementWalker {\n  let temporaryFilter: HTMLElementFilter | undefined;\n  const treeWalker = targetDocument.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {\n    acceptNode(node: Node) {\n      if (!isHTMLElement(node)) {\n        return NodeFilter.FILTER_REJECT;\n      }\n      const filterResult = filter(node);\n      return filterResult === NodeFilter.FILTER_ACCEPT ? temporaryFilter?.(node) ?? filterResult : filterResult;\n    },\n  });\n  return {\n    get root() {\n      return treeWalker.root as HTMLElement;\n    },\n    get currentElement() {\n      return treeWalker.currentNode as HTMLElement;\n    },\n    set currentElement(element) {\n      treeWalker.currentNode = element;\n    },\n    firstChild: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.firstChild() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n    lastChild: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.lastChild() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n    nextElement: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.nextNode() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n    nextSibling: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.nextSibling() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n    parentElement: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.parentNode() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n    previousElement: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.previousNode() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n    previousSibling: localFilter => {\n      temporaryFilter = localFilter;\n      const result = treeWalker.previousSibling() as HTMLElement | null;\n      temporaryFilter = undefined;\n      return result;\n    },\n  };\n}\n"],"names":["createHTMLElementWalker","root","targetDocument","filter","NodeFilter","FILTER_ACCEPT","temporaryFilter","treeWalker","createTreeWalker","SHOW_ELEMENT","acceptNode","node","isHTMLElement","FILTER_REJECT","filterResult","currentElement","currentNode","element","firstChild","localFilter","result","undefined","lastChild","nextElement","nextNode","nextSibling","parentElement","parentNode","previousElement","previousNode","previousSibling"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAgBgBA;;;eAAAA;;;gCAhBc;AAgBvB,SAASA,wBACdC,IAAiB,EACjBC,cAAwB,EACxBC,SAA4B,IAAMC,WAAWC,aAAa;IAE1D,IAAIC;IACJ,MAAMC,aAAaL,eAAeM,gBAAgB,CAACP,MAAMG,WAAWK,YAAY,EAAE;QAChFC,YAAWC,IAAU;YACnB,IAAI,CAACC,IAAAA,6BAAAA,EAAcD,OAAO;gBACxB,OAAOP,WAAWS,aAAa;YACjC;YACA,MAAMC,eAAeX,OAAOQ;gBACuBL;YAAnD,OAAOQ,iBAAiBV,WAAWC,aAAa,GAAGC,CAAAA,mBAAAA,oBAAAA,QAAAA,oBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,gBAAkBK,KAAAA,MAAAA,QAAlBL,qBAAAA,KAAAA,IAAAA,mBAA2BQ,eAAeA;QAC/F;IACF;IACA,OAAO;QACL,IAAIb,QAAO;YACT,OAAOM,WAAWN,IAAI;QACxB;QACA,IAAIc,kBAAiB;YACnB,OAAOR,WAAWS,WAAW;QAC/B;QACA,IAAID,gBAAeE,QAAS;YAC1BV,WAAWS,WAAW,GAAGC;QAC3B;QACAC,YAAYC,CAAAA;YACVb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWW,UAAU;YACpCZ,kBAAkBe;YAClB,OAAOD;QACT;QACAE,WAAWH,CAAAA;YACTb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWe,SAAS;YACnChB,kBAAkBe;YAClB,OAAOD;QACT;QACAG,aAAaJ,CAAAA;YACXb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWiB,QAAQ;YAClClB,kBAAkBe;YAClB,OAAOD;QACT;QACAK,aAAaN,CAAAA;YACXb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWkB,WAAW;YACrCnB,kBAAkBe;YAClB,OAAOD;QACT;QACAM,eAAeP,CAAAA;YACbb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWoB,UAAU;YACpCrB,kBAAkBe;YAClB,OAAOD;QACT;QACAQ,iBAAiBT,CAAAA;YACfb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWsB,YAAY;YACtCvB,kBAAkBe;YAClB,OAAOD;QACT;QACAU,iBAAiBX,CAAAA;YACfb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWuB,eAAe;YACzCxB,kBAAkBe;YAClB,OAAOD;QACT;IACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"sources":["createHeadlessTree.js"],"sourcesContent":["/**\n * creates a list of virtual tree items\n * and provides a map to access each item by id\n */ export function createHeadlessTree(initialProps = []) {\n    const root = createHeadlessTreeRootItem();\n    const itemsPerValue = new Map([\n        [\n            root.value,\n            root\n        ]\n    ]);\n    const headlessTree = {\n        root,\n        get size () {\n            return itemsPerValue.size;\n        },\n        getParent: (key)=>{\n            var _itemsPerValue_get;\n            var _itemsPerValue_get_parentValue, _itemsPerValue_get1;\n            return (_itemsPerValue_get1 = itemsPerValue.get((_itemsPerValue_get_parentValue = (_itemsPerValue_get = itemsPerValue.get(key)) === null || _itemsPerValue_get === void 0 ? void 0 : _itemsPerValue_get.parentValue) !== null && _itemsPerValue_get_parentValue !== void 0 ? _itemsPerValue_get_parentValue : root.value)) !== null && _itemsPerValue_get1 !== void 0 ? _itemsPerValue_get1 : root;\n        },\n        get: (key)=>itemsPerValue.get(key),\n        has: (key)=>itemsPerValue.has(key),\n        add (props) {\n            const { parentValue = headlessTreeRootId, ...propsWithoutParentValue } = props;\n            const parentItem = itemsPerValue.get(parentValue);\n            if (!parentItem) {\n                if (process.env.NODE_ENV === 'development') {\n                    // eslint-disable-next-line no-console\n                    console.error(`@fluentui/react-tree [createHeadlessTree]:\nTreeItem \"${props.value}\" is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children`);\n                }\n                return;\n            }\n            parentItem.itemType = 'branch';\n            var _propsWithoutParentValue_itemType;\n            const item = {\n                value: props.value,\n                getTreeItemProps: ()=>({\n                        ...propsWithoutParentValue,\n                        parentValue,\n                        'aria-level': item.level,\n                        'aria-posinset': item.position,\n                        'aria-setsize': parentItem.childrenValues.length,\n                        itemType: item.itemType\n                    }),\n                itemType: (_propsWithoutParentValue_itemType = propsWithoutParentValue.itemType) !== null && _propsWithoutParentValue_itemType !== void 0 ? _propsWithoutParentValue_itemType : 'leaf',\n                level: parentItem.level + 1,\n                parentValue,\n                childrenValues: [],\n                index: -1,\n                position: parentItem.childrenValues.push(props.value)\n            };\n            itemsPerValue.set(item.value, item);\n        },\n        subtree: (key)=>HeadlessTreeSubtreeGenerator(key, headlessTree),\n        children: (key)=>HeadlessTreeChildrenGenerator(key, headlessTree),\n        ancestors: (key)=>HeadlessTreeAncestorsGenerator(key, headlessTree),\n        visibleItems: (openItems)=>HeadlessTreeVisibleItemsGenerator(openItems, headlessTree)\n    };\n    initialProps.forEach(headlessTree.add);\n    return headlessTree;\n}\nexport const headlessTreeRootId = '__fuiHeadlessTreeRoot';\nfunction createHeadlessTreeRootItem() {\n    return {\n        parentValue: undefined,\n        value: headlessTreeRootId,\n        itemType: 'branch',\n        getTreeItemProps: ()=>{\n            if (process.env.NODE_ENV !== 'production') {\n                // eslint-disable-next-line no-console\n                console.error(`@fluentui/react-tree [createHeadlessTree]:\nInternal error, trying to access treeitem props from invalid root element`);\n            }\n            return {\n                id: headlessTreeRootId,\n                parentValue: undefined,\n                value: headlessTreeRootId,\n                'aria-setsize': -1,\n                'aria-level': -1,\n                'aria-posinset': -1,\n                itemType: 'branch'\n            };\n        },\n        childrenValues: [],\n        get index () {\n            if (process.env.NODE_ENV !== 'production') {\n                // eslint-disable-next-line no-console\n                console.error(`@fluentui/react-tree [createHeadlessTree]:\nInternal error, trying to access treeitem props from invalid root element`);\n            }\n            return -1;\n        },\n        get position () {\n            if (process.env.NODE_ENV !== 'production') {\n                // eslint-disable-next-line no-console\n                console.error(`@fluentui/react-tree [createHeadlessTree]:\nInternal error, trying to access treeitem props from invalid root element`);\n            }\n            return -1;\n        },\n        level: 0\n    };\n}\n/**\n * Generator that returns all subtree of a given virtual tree item\n * @param key - the key of the item to get the subtree from\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeSubtreeGenerator(key, virtualTreeItems) {\n    const item = virtualTreeItems.get(key);\n    if (!item || item.childrenValues.length === 0) {\n        return;\n    }\n    for (const childValue of item.childrenValues){\n        yield virtualTreeItems.get(childValue);\n        yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);\n    }\n}\n/**\n * Generator that returns all children of a given virtual tree item\n * @param key - the key of the item to get the children from\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeChildrenGenerator(key, virtualTreeItems) {\n    const item = virtualTreeItems.get(key);\n    if (!item || item.childrenValues.length === 0) {\n        return;\n    }\n    for (const childValue of item.childrenValues){\n        yield virtualTreeItems.get(childValue);\n    }\n}\n/**\n * Generator that returns all ancestors of a given virtual tree item\n * @param key - the key of the item to get the children from\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeAncestorsGenerator(key, virtualTreeItems) {\n    let parent = virtualTreeItems.getParent(key);\n    while(parent !== virtualTreeItems.root){\n        yield parent;\n        parent = virtualTreeItems.getParent(parent.value);\n    }\n}\n/**\n * Generator that returns all visible items of a given virtual tree\n * @param openItems - the open items of the tree\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeVisibleItemsGenerator(openItems, virtualTreeItems) {\n    let index = 0;\n    for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)){\n        if (isItemVisible(item, openItems, virtualTreeItems)) {\n            item.index = index++;\n            yield item;\n        }\n    }\n}\nfunction isItemVisible(item, openItems, virtualTreeItems) {\n    if (item.level === 1) {\n        return true;\n    }\n    while(item.parentValue && item.parentValue !== virtualTreeItems.root.value){\n        if (!openItems.has(item.parentValue)) {\n            return false;\n        }\n        const parent = virtualTreeItems.get(item.parentValue);\n        if (!parent) {\n            return false;\n        }\n        item = parent;\n    }\n    return true;\n}\n"],"names":["createHeadlessTree","headlessTreeRootId","initialProps","root","createHeadlessTreeRootItem","itemsPerValue","Map","value","headlessTree","size","getParent","key","_itemsPerValue_get","_itemsPerValue_get_parentValue","_itemsPerValue_get1","get","parentValue","has","add","props","propsWithoutParentValue","parentItem","process","env","NODE_ENV","console","error","itemType","_propsWithoutParentValue_itemType","item","getTreeItemProps","level","position","childrenValues","length","index","push","set","subtree","HeadlessTreeSubtreeGenerator","children","HeadlessTreeChildrenGenerator","ancestors","HeadlessTreeAncestorsGenerator","visibleItems","openItems","HeadlessTreeVisibleItemsGenerator","forEach","undefined","id","virtualTreeItems","childValue","parent","isItemVisible"],"mappings":"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"}
+{"version":3,"sources":["createHeadlessTree.ts"],"sourcesContent":["import { TreeItemProps, TreeItemType, TreeItemValue } from '../TreeItem';\nimport { ImmutableSet } from './ImmutableSet';\n\nexport type HeadlessTreeItemProps = Omit<TreeItemProps, 'itemType' | 'value'> & {\n  value: TreeItemValue;\n  itemType?: TreeItemType;\n  parentValue?: TreeItemValue;\n};\n\n/**\n * The item that is returned by `createHeadlessTree`, it represents a wrapper around the properties provided to\n * `createHeadlessTree` but with extra information that might be useful on virtual tree scenarios\n */\nexport type HeadlessTreeItem<Props extends HeadlessTreeItemProps> = {\n  level: number;\n  index: number;\n  position: number;\n  childrenValues: TreeItemValue[];\n  value: TreeItemValue;\n  parentValue: TreeItemValue | undefined;\n  itemType: TreeItemType;\n  getTreeItemProps(): Required<Pick<Props, 'value' | 'aria-setsize' | 'aria-level' | 'aria-posinset' | 'itemType'>> &\n    Props;\n};\n\n/**\n * @internal\n */\nexport type HeadlessTree<Props extends HeadlessTreeItemProps> = {\n  /**\n   * the number of items in the virtual tree\n   */\n  readonly size: number;\n  /**\n   * the root item of the virtual tree\n   */\n  root: HeadlessTreeItem<HeadlessTreeItemProps>;\n  /**\n   * method to get a virtual tree item by its value\n   * @param key - the key of the item to get\n   */\n  get(value: TreeItemValue): HeadlessTreeItem<Props> | undefined;\n  /**\n   * method to check if a virtual tree item exists by its value\n   * @param value - the value of the item to check if exists\n   */\n  has(value: TreeItemValue): boolean;\n  /**\n   * method to add a new virtual tree item to the virtual tree\n   * @param props - the props of the item to add\n   */\n  add(props: Props): void;\n  /**\n   * method to remove a virtual tree item from the virtual tree.\n   * When an item is removed:\n   * 1. all its children are also removed\n   * 2. all its siblings are repositioned\n   * @param value - the value of the item to remove\n   */\n  // remove(value: TreeItemValue): void;\n  /**\n   * method to get the parent of a virtual tree item by its value\n   * @param value - the value of the item to get the parent from\n   */\n  getParent(value: TreeItemValue): HeadlessTreeItem<Props>;\n  /**\n   * method to get the subtree of a virtual tree item by its value\n   * @param value - the value of the item to get the subtree from\n   */\n  subtree(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n  /**\n   * method to get the children of a virtual tree item by its value\n   * @param value - the value of the item to get the children from\n   */\n  children(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n  /**\n   * method to get the visible items of a virtual tree\n   * @param openItems - the open items of the tree\n   */\n  visibleItems(openItems: ImmutableSet<TreeItemValue>): IterableIterator<HeadlessTreeItem<Props>>;\n  /**\n   * method to get the ancestors of a virtual tree item by its value\n   * @param value - the value of the item to get the ancestors from\n   */\n  ancestors(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n};\n\n/**\n * creates a list of virtual tree items\n * and provides a map to access each item by id\n */\nexport function createHeadlessTree<Props extends HeadlessTreeItemProps>(\n  initialProps: Props[] = [],\n): HeadlessTree<Props> {\n  const root = createHeadlessTreeRootItem();\n  const itemsPerValue = new Map<TreeItemValue, HeadlessTreeItem<HeadlessTreeItemProps>>([[root.value, root]]);\n\n  const headlessTree: HeadlessTree<HeadlessTreeItemProps> = {\n    root,\n    get size() {\n      return itemsPerValue.size;\n    },\n    getParent: key => itemsPerValue.get(itemsPerValue.get(key)?.parentValue ?? root.value) ?? root,\n    get: key => itemsPerValue.get(key),\n    has: key => itemsPerValue.has(key),\n    add(props) {\n      const { parentValue = headlessTreeRootId, ...propsWithoutParentValue } = props;\n      const parentItem = itemsPerValue.get(parentValue);\n      if (!parentItem) {\n        if (process.env.NODE_ENV === 'development') {\n          // eslint-disable-next-line no-console\n          console.error(/* #__DE-INDENT__ */ `\n            @fluentui/react-tree [createHeadlessTree]:\n            TreeItem \"${props.value}\" is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children\n          `);\n        }\n        return;\n      }\n      parentItem.itemType = 'branch';\n\n      const item: HeadlessTreeItem<HeadlessTreeItemProps> = {\n        value: props.value,\n        getTreeItemProps: () => ({\n          ...propsWithoutParentValue,\n          parentValue,\n          'aria-level': item.level,\n          'aria-posinset': item.position,\n          'aria-setsize': parentItem.childrenValues.length,\n          itemType: item.itemType,\n        }),\n        itemType: propsWithoutParentValue.itemType ?? 'leaf',\n        level: parentItem.level + 1,\n        parentValue,\n        childrenValues: [],\n        index: -1,\n        position: parentItem.childrenValues.push(props.value),\n      };\n      itemsPerValue.set(item.value, item);\n    },\n    subtree: key => HeadlessTreeSubtreeGenerator(key, headlessTree),\n    children: key => HeadlessTreeChildrenGenerator(key, headlessTree),\n    ancestors: key => HeadlessTreeAncestorsGenerator(key, headlessTree),\n    visibleItems: openItems => HeadlessTreeVisibleItemsGenerator(openItems, headlessTree),\n  };\n\n  initialProps.forEach(headlessTree.add);\n\n  return headlessTree as HeadlessTree<Props>;\n}\n\nexport const headlessTreeRootId = '__fuiHeadlessTreeRoot';\n\nfunction createHeadlessTreeRootItem(): HeadlessTreeItem<HeadlessTreeItemProps> {\n  return {\n    parentValue: undefined,\n    value: headlessTreeRootId,\n    itemType: 'branch',\n    getTreeItemProps: () => {\n      if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error(/* #__DE-INDENT__ */ `\n          @fluentui/react-tree [createHeadlessTree]:\n          Internal error, trying to access treeitem props from invalid root element\n        `);\n      }\n      return {\n        id: headlessTreeRootId,\n        parentValue: undefined,\n        value: headlessTreeRootId,\n        'aria-setsize': -1,\n        'aria-level': -1,\n        'aria-posinset': -1,\n        itemType: 'branch',\n      };\n    },\n    childrenValues: [],\n    get index() {\n      if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error(/* #__DE-INDENT__ */ `\n          @fluentui/react-tree [createHeadlessTree]:\n          Internal error, trying to access treeitem props from invalid root element\n        `);\n      }\n      return -1;\n    },\n    get position() {\n      if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error(/* #__DE-INDENT__ */ `\n          @fluentui/react-tree [createHeadlessTree]:\n          Internal error, trying to access treeitem props from invalid root element\n        `);\n      }\n      return -1;\n    },\n    level: 0,\n  };\n}\n\n/**\n * Generator that returns all subtree of a given virtual tree item\n * @param key - the key of the item to get the subtree from\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeSubtreeGenerator<Props extends HeadlessTreeItemProps>(\n  key: TreeItemValue,\n  virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n  const item = virtualTreeItems.get(key);\n  if (!item || item.childrenValues.length === 0) {\n    return;\n  }\n  for (const childValue of item.childrenValues) {\n    yield virtualTreeItems.get(childValue)!;\n    yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);\n  }\n}\n\n/**\n * Generator that returns all children of a given virtual tree item\n * @param key - the key of the item to get the children from\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeChildrenGenerator<Props extends HeadlessTreeItemProps>(\n  key: TreeItemValue,\n  virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n  const item = virtualTreeItems.get(key);\n  if (!item || item.childrenValues.length === 0) {\n    return;\n  }\n  for (const childValue of item.childrenValues) {\n    yield virtualTreeItems.get(childValue)!;\n  }\n}\n\n/**\n * Generator that returns all ancestors of a given virtual tree item\n * @param key - the key of the item to get the children from\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeAncestorsGenerator<Props extends HeadlessTreeItemProps>(\n  key: TreeItemValue,\n  virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n  let parent = virtualTreeItems.getParent(key);\n  while (parent !== virtualTreeItems.root) {\n    yield parent;\n    parent = virtualTreeItems.getParent(parent.value);\n  }\n}\n\n/**\n * Generator that returns all visible items of a given virtual tree\n * @param openItems - the open items of the tree\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeVisibleItemsGenerator<Props extends HeadlessTreeItemProps>(\n  openItems: ImmutableSet<TreeItemValue>,\n  virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n  let index = 0;\n  for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)) {\n    if (isItemVisible(item, openItems, virtualTreeItems)) {\n      item.index = index++;\n      yield item;\n    }\n  }\n}\n\nfunction isItemVisible(\n  item: HeadlessTreeItem<HeadlessTreeItemProps>,\n  openItems: ImmutableSet<TreeItemValue>,\n  virtualTreeItems: HeadlessTree<HeadlessTreeItemProps>,\n) {\n  if (item.level === 1) {\n    return true;\n  }\n  while (item.parentValue && item.parentValue !== virtualTreeItems.root.value) {\n    if (!openItems.has(item.parentValue)) {\n      return false;\n    }\n    const parent = virtualTreeItems.get(item.parentValue);\n    if (!parent) {\n      return false;\n    }\n    item = parent;\n  }\n  return true;\n}\n"],"names":["createHeadlessTree","headlessTreeRootId","initialProps","root","createHeadlessTreeRootItem","itemsPerValue","Map","value","headlessTree","size","getParent","key","get","parentValue","has","add","props","propsWithoutParentValue","parentItem","process","env","NODE_ENV","console","error","itemType","item","getTreeItemProps","level","position","childrenValues","length","index","push","set","subtree","HeadlessTreeSubtreeGenerator","children","HeadlessTreeChildrenGenerator","ancestors","HeadlessTreeAncestorsGenerator","visibleItems","openItems","HeadlessTreeVisibleItemsGenerator","forEach","undefined","id","virtualTreeItems","childValue","parent","isItemVisible"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["createOpenItems.js"],"sourcesContent":["import { ImmutableSet } from './ImmutableSet';\nexport function createOpenItems(iterable) {\n    if (iterable === undefined) {\n        return ImmutableSet.empty;\n    }\n    if (ImmutableSet.isImmutableSet(iterable)) {\n        return iterable;\n    }\n    return ImmutableSet.create(iterable);\n}\n"],"names":["createOpenItems","iterable","undefined","ImmutableSet","empty","isImmutableSet","create"],"mappings":";;;;+BACgBA;;;eAAAA;;;8BADa;AACtB,SAASA,gBAAgBC,QAAQ;IACpC,IAAIA,aAAaC,WAAW;QACxB,OAAOC,0BAAY,CAACC,KAAK;IAC7B;IACA,IAAID,0BAAY,CAACE,cAAc,CAACJ,WAAW;QACvC,OAAOA;IACX;IACA,OAAOE,0BAAY,CAACG,MAAM,CAACL;AAC/B"}
+{"version":3,"sources":["createOpenItems.ts"],"sourcesContent":["import { ImmutableSet } from './ImmutableSet';\nimport type { TreeItemValue } from '../TreeItem';\n\nexport function createOpenItems(iterable?: Iterable<TreeItemValue>) {\n  if (iterable === undefined) {\n    return ImmutableSet.empty;\n  }\n  if (ImmutableSet.isImmutableSet<TreeItemValue>(iterable)) {\n    return iterable;\n  }\n  return ImmutableSet.create(iterable);\n}\n"],"names":["createOpenItems","iterable","undefined","ImmutableSet","empty","isImmutableSet","create"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;8BAHa;AAGtB,SAASA,gBAAgBC,QAAkC;IAChE,IAAIA,aAAaC,WAAW;QAC1B,OAAOC,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAID,0BAAAA,CAAaE,cAAc,CAAgBJ,WAAW;QACxD,OAAOA;IACT;IACA,OAAOE,0BAAAA,CAAaG,MAAM,CAACL;AAC7B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["flattenTree.js"],"sourcesContent":["function flattenTreeRecursive(items, parent, level = 1) {\n    return items.reduce((acc, { subtree, ...item }, index)=>{\n        const flatTreeItem = {\n            'aria-level': level,\n            'aria-posinset': index + 1,\n            'aria-setsize': items.length,\n            parentValue: parent === null || parent === void 0 ? void 0 : parent.value,\n            ...item\n        };\n        acc.push(flatTreeItem);\n        if (subtree !== undefined) {\n            acc.push(...flattenTreeRecursive(subtree, flatTreeItem, level + 1));\n        }\n        return acc;\n    }, []);\n}\n/**\n * Converts a nested structure to a flat one which can be consumed by `useFlatTreeItems`\n * @example\n * ```tsx\n * const defaultItems = flattenTree_unstable([\n *  {\n *    children: <TreeItemLayout>level 1, item 1</TreeItemLayout>,\n *    subtree: [\n *      {\n *        children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n *      },\n *      {\n *        children: <TreeItemLayout>level 2, item 2</TreeItemLayout>,\n *      },\n *      {\n *        children: <TreeItemLayout>level 2, item 3</TreeItemLayout>,\n *      },\n *    ],\n *  },\n *  {\n *    children: <TreeItemLayout>level 1, item 2</TreeItemLayout>,\n *    subtree: [\n *      {\n *        children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n *        subtree: [\n *          {\n *            children: <TreeItemLayout>level 3, item 1</TreeItemLayout>,\n *            subtree: [\n *              {\n *                children: <TreeItemLayout>level 4, item 1</TreeItemLayout>,\n *              },\n *            ],\n *          },\n *        ],\n *      },\n *    ],\n *  },\n * ]);\n * ```\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nexport const flattenTree_unstable = (items)=>flattenTreeRecursive(items);\n"],"names":["flattenTree_unstable","flattenTreeRecursive","items","parent","level","reduce","acc","subtree","item","index","flatTreeItem","length","parentValue","value","push","undefined"],"mappings":";;;;+BAwDaA;;;eAAAA;;;AAxDb,SAASC,qBAAqBC,KAAK,EAAEC,MAAM,EAAEC,QAAQ,CAAC;IAClD,OAAOF,MAAMG,MAAM,CAAC,CAACC,KAAK,EAAEC,OAAO,EAAE,GAAGC,MAAM,EAAEC;QAC5C,MAAMC,eAAe;YACjB,cAAcN;YACd,iBAAiBK,QAAQ;YACzB,gBAAgBP,MAAMS,MAAM;YAC5BC,aAAaT,WAAW,QAAQA,WAAW,KAAK,IAAI,KAAK,IAAIA,OAAOU,KAAK;YACzE,GAAGL,IAAI;QACX;QACAF,IAAIQ,IAAI,CAACJ;QACT,IAAIH,YAAYQ,WAAW;YACvBT,IAAIQ,IAAI,IAAIb,qBAAqBM,SAASG,cAAcN,QAAQ;QACpE;QACA,OAAOE;IACX,GAAG,EAAE;AACT;AAyCO,MAAMN,uBAAuB,CAACE,QAAQD,qBAAqBC"}
+{"version":3,"sources":["flattenTree.ts"],"sourcesContent":["import { HeadlessFlatTreeItemProps } from '../FlatTree';\nimport { TreeItemProps, TreeItemValue } from '../TreeItem';\n\nexport type FlattenTreeItem<Props extends TreeItemProps> = Omit<Props, 'subtree' | 'itemType'> & {\n  value: TreeItemValue;\n  subtree?: FlattenTreeItem<Props>[];\n};\n\nexport type FlattenedTreeItem<Props extends TreeItemProps> = HeadlessFlatTreeItemProps & Props;\n\nfunction flattenTreeRecursive<Props extends TreeItemProps>(\n  items: FlattenTreeItem<Props>[],\n  parent?: HeadlessFlatTreeItemProps & Props,\n  level = 1,\n): FlattenedTreeItem<Props>[] {\n  return items.reduce<FlattenedTreeItem<Props>[]>((acc, { subtree, ...item }, index) => {\n    const flatTreeItem = {\n      'aria-level': level,\n      'aria-posinset': index + 1,\n      'aria-setsize': items.length,\n      parentValue: parent?.value,\n      ...item,\n    } as FlattenedTreeItem<Props>;\n    acc.push(flatTreeItem);\n    if (subtree !== undefined) {\n      acc.push(...flattenTreeRecursive<Props>(subtree, flatTreeItem, level + 1));\n    }\n    return acc;\n  }, []);\n}\n\n/**\n * Converts a nested structure to a flat one which can be consumed by `useFlatTreeItems`\n * @example\n * ```tsx\n * const defaultItems = flattenTree_unstable([\n *  {\n *    children: <TreeItemLayout>level 1, item 1</TreeItemLayout>,\n *    subtree: [\n *      {\n *        children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n *      },\n *      {\n *        children: <TreeItemLayout>level 2, item 2</TreeItemLayout>,\n *      },\n *      {\n *        children: <TreeItemLayout>level 2, item 3</TreeItemLayout>,\n *      },\n *    ],\n *  },\n *  {\n *    children: <TreeItemLayout>level 1, item 2</TreeItemLayout>,\n *    subtree: [\n *      {\n *        children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n *        subtree: [\n *          {\n *            children: <TreeItemLayout>level 3, item 1</TreeItemLayout>,\n *            subtree: [\n *              {\n *                children: <TreeItemLayout>level 4, item 1</TreeItemLayout>,\n *              },\n *            ],\n *          },\n *        ],\n *      },\n *    ],\n *  },\n * ]);\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const flattenTree_unstable = <Props extends TreeItemProps>(\n  items: FlattenTreeItem<Props>[],\n): FlattenedTreeItem<Props>[] => flattenTreeRecursive(items);\n"],"names":["flattenTree_unstable","flattenTreeRecursive","items","parent","level","reduce","acc","subtree","item","index","flatTreeItem","length","parentValue","value","push","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAwEaA;;;eAAAA;;;AA9Db,SAASC,qBACPC,KAA+B,EAC/BC,MAA0C,EAC1CC,QAAQ,CAAC;IAET,OAAOF,MAAMG,MAAM,CAA6B,CAACC,KAAK,EAAEC,OAAO,EAAE,GAAGC,MAAM,EAAEC;QAC1E,MAAMC,eAAe;YACnB,cAAcN;YACd,iBAAiBK,QAAQ;YACzB,gBAAgBP,MAAMS,MAAM;YAC5BC,aAAaT,WAAAA,QAAAA,WAAAA,KAAAA,IAAAA,KAAAA,IAAAA,OAAQU,KAAK;YAC1B,GAAGL,IAAI;QACT;QACAF,IAAIQ,IAAI,CAACJ;QACT,IAAIH,YAAYQ,WAAW;YACzBT,IAAIQ,IAAI,IAAIb,qBAA4BM,SAASG,cAAcN,QAAQ;QACzE;QACA,OAAOE;IACT,GAAG,EAAE;AACP;AA2CO,MAAMN,uBAAuB,CAClCE,QAC+BD,qBAAqBC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["getTreeItemValueFromElement.js"],"sourcesContent":["export const dataTreeItemValueAttrName = 'data-fui-tree-item-value';\nexport const getTreeItemValueFromElement = (element)=>{\n    return element.getAttribute(dataTreeItemValueAttrName);\n};\n"],"names":["dataTreeItemValueAttrName","getTreeItemValueFromElement","element","getAttribute"],"mappings":";;;;;;;;;;;IAAaA,yBAAyB;eAAzBA;;IACAC,2BAA2B;eAA3BA;;;AADN,MAAMD,4BAA4B;AAClC,MAAMC,8BAA8B,CAACC;IACxC,OAAOA,QAAQC,YAAY,CAACH;AAChC"}
+{"version":3,"sources":["getTreeItemValueFromElement.ts"],"sourcesContent":["import type { TreeItemValue } from '../TreeItem';\n\nexport const dataTreeItemValueAttrName = 'data-fui-tree-item-value';\n\nexport const getTreeItemValueFromElement = (element: HTMLElement) => {\n  return element.getAttribute(dataTreeItemValueAttrName) as TreeItemValue | null;\n};\n"],"names":["dataTreeItemValueAttrName","getTreeItemValueFromElement","element","getAttribute"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,yBAAAA;eAAAA;;IAEAC,2BAAAA;eAAAA;;;AAFN,MAAMD,4BAA4B;AAElC,MAAMC,8BAA8B,CAACC;IAC1C,OAAOA,QAAQC,YAAY,CAACH;AAC9B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["nextTypeAheadElement.js"],"sourcesContent":["export function nextTypeAheadElement(treeWalker, key) {\n    const keyToLowerCase = key.toLowerCase();\n    const typeAheadFilter = (element)=>{\n        var _element_textContent;\n        return ((_element_textContent = element.textContent) === null || _element_textContent === void 0 ? void 0 : _element_textContent.trim().charAt(0).toLowerCase()) === keyToLowerCase ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n    };\n    let nextElement = treeWalker.nextElement(typeAheadFilter);\n    if (!nextElement) {\n        treeWalker.currentElement = treeWalker.root;\n        nextElement = treeWalker.nextElement(typeAheadFilter);\n    }\n    return nextElement;\n}\n"],"names":["nextTypeAheadElement","treeWalker","key","keyToLowerCase","toLowerCase","typeAheadFilter","element","_element_textContent","textContent","trim","charAt","NodeFilter","FILTER_ACCEPT","FILTER_SKIP","nextElement","currentElement","root"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,qBAAqBC,UAAU,EAAEC,GAAG;IAChD,MAAMC,iBAAiBD,IAAIE,WAAW;IACtC,MAAMC,kBAAkB,CAACC;QACrB,IAAIC;QACJ,OAAO,AAAC,CAAA,AAACA,CAAAA,uBAAuBD,QAAQE,WAAW,AAAD,MAAO,QAAQD,yBAAyB,KAAK,IAAI,KAAK,IAAIA,qBAAqBE,IAAI,GAAGC,MAAM,CAAC,GAAGN,WAAW,EAAC,MAAOD,iBAAiBQ,WAAWC,aAAa,GAAGD,WAAWE,WAAW;IAC3O;IACA,IAAIC,cAAcb,WAAWa,WAAW,CAACT;IACzC,IAAI,CAACS,aAAa;QACdb,WAAWc,cAAc,GAAGd,WAAWe,IAAI;QAC3CF,cAAcb,WAAWa,WAAW,CAACT;IACzC;IACA,OAAOS;AACX"}
+{"version":3,"sources":["nextTypeAheadElement.ts"],"sourcesContent":["import { HTMLElementWalker } from './createHTMLElementWalker';\n\nexport function nextTypeAheadElement(treeWalker: HTMLElementWalker, key: string) {\n  const keyToLowerCase = key.toLowerCase();\n  const typeAheadFilter = (element: HTMLElement) => {\n    return element.textContent?.trim().charAt(0).toLowerCase() === keyToLowerCase\n      ? NodeFilter.FILTER_ACCEPT\n      : NodeFilter.FILTER_SKIP;\n  };\n  let nextElement = treeWalker.nextElement(typeAheadFilter);\n  if (!nextElement) {\n    treeWalker.currentElement = treeWalker.root;\n    nextElement = treeWalker.nextElement(typeAheadFilter);\n  }\n  return nextElement;\n}\n"],"names":["nextTypeAheadElement","treeWalker","key","keyToLowerCase","toLowerCase","typeAheadFilter","element","textContent","trim","charAt","NodeFilter","FILTER_ACCEPT","FILTER_SKIP","nextElement","currentElement","root"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,qBAAqBC,UAA6B,EAAEC,GAAW;IAC7E,MAAMC,iBAAiBD,IAAIE,WAAW;IACtC,MAAMC,kBAAkB,CAACC;YAChBA;QAAP,OAAOA,CAAAA,CAAAA,uBAAAA,QAAQC,WAAW,AAAXA,MAAW,QAAnBD,yBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,qBAAqBE,IAAI,GAAGC,MAAM,CAAC,GAAGL,WAAW,EAAA,MAAOD,iBAC3DO,WAAWC,aAAa,GACxBD,WAAWE,WAAW;IAC5B;IACA,IAAIC,cAAcZ,WAAWY,WAAW,CAACR;IACzC,IAAI,CAACQ,aAAa;QAChBZ,WAAWa,cAAc,GAAGb,WAAWc,IAAI;QAC3CF,cAAcZ,WAAWY,WAAW,CAACR;IACvC;IACA,OAAOQ;AACT"}

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

@@ -1 +1 @@
-{"version":3,"sources":["normalizeOpenItems.js"],"sourcesContent":["export function normalizeOpenItems(openSubtrees, options) {\n    if (!openSubtrees) {\n        return (options === null || options === void 0 ? void 0 : options.keepUndefined) ? undefined : [];\n    }\n    return Array.isArray(openSubtrees) ? openSubtrees : [\n        openSubtrees\n    ];\n}\n"],"names":["normalizeOpenItems","openSubtrees","options","keepUndefined","undefined","Array","isArray"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,mBAAmBC,YAAY,EAAEC,OAAO;IACpD,IAAI,CAACD,cAAc;QACf,OAAO,AAACC,CAAAA,YAAY,QAAQA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQC,aAAa,AAAD,IAAKC,YAAY,EAAE;IACrG;IACA,OAAOC,MAAMC,OAAO,CAACL,gBAAgBA,eAAe;QAChDA;KACH;AACL"}
+{"version":3,"sources":["normalizeOpenItems.ts"],"sourcesContent":["export function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: false;\n  },\n): string[];\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined: true;\n  },\n): string[] | undefined;\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: boolean;\n  },\n): string[] | undefined {\n  if (!openSubtrees) {\n    return options?.keepUndefined ? undefined : [];\n  }\n  return Array.isArray(openSubtrees) ? openSubtrees : [openSubtrees];\n}\n"],"names":["normalizeOpenItems","openSubtrees","options","keepUndefined","undefined","Array","isArray"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BAcgBA;;;eAAAA;;;AAAT,SAASA,mBACdC,YAAgC,EAChCC,OAEC;IAED,IAAI,CAACD,cAAc;QACjB,OAAOC,CAAAA,YAAAA,QAAAA,YAAAA,KAAAA,IAAAA,KAAAA,IAAAA,QAASC,aAAa,AAAbA,IAAgBC,YAAY,EAAE;IAChD;IACA,OAAOC,MAAMC,OAAO,CAACL,gBAAgBA,eAAe;QAACA;KAAa;AACpE"}

package/lib-commonjs/utils/tokens.js

@@ -9,14 +9,14 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    treeItemLevelToken: function() {
-        return treeItemLevelToken;
-    },
     treeAvatarSize: function() {
         return treeAvatarSize;
     },
     treeDataTypes: function() {
         return treeDataTypes;
+    },
+    treeItemLevelToken: function() {
+        return treeItemLevelToken;
     }
 });
 const _keyboardkeys = require("@fluentui/keyboard-keys");

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

@@ -1 +1 @@
-{"version":3,"sources":["tokens.js"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';\nexport const treeItemLevelToken = '--fluent-TreeItem--level';\nexport const treeAvatarSize = {\n    medium: 32,\n    small: 24\n};\nexport const treeDataTypes = {\n    ArrowLeft,\n    ArrowRight,\n    Enter,\n    Click: 'Click',\n    ExpandIconClick: 'ExpandIconClick',\n    End,\n    Home,\n    ArrowUp,\n    ArrowDown,\n    TypeAhead: 'TypeAhead',\n    Change: 'Change'\n};\n"],"names":["treeItemLevelToken","treeAvatarSize","treeDataTypes","medium","small","ArrowLeft","ArrowRight","Enter","Click","ExpandIconClick","End","Home","ArrowUp","ArrowDown","TypeAhead","Change"],"mappings":";;;;;;;;;;;IACaA,kBAAkB;eAAlBA;;IACAC,cAAc;eAAdA;;IAIAC,aAAa;eAAbA;;;8BAN+D;AACrE,MAAMF,qBAAqB;AAC3B,MAAMC,iBAAiB;IAC1BE,QAAQ;IACRC,OAAO;AACX;AACO,MAAMF,gBAAgB;IACzBG,WAAAA,uBAAS;IACTC,YAAAA,wBAAU;IACVC,OAAAA,mBAAK;IACLC,OAAO;IACPC,iBAAiB;IACjBC,KAAAA,iBAAG;IACHC,MAAAA,kBAAI;IACJC,SAAAA,qBAAO;IACPC,WAAAA,uBAAS;IACTC,WAAW;IACXC,QAAQ;AACZ"}
+{"version":3,"sources":["tokens.ts"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';\nimport { TreeCheckedChangeData, TreeNavigationData_unstable, TreeOpenChangeData } from '../Tree';\n\nexport const treeItemLevelToken = '--fluent-TreeItem--level' as const;\n\nexport const treeAvatarSize = {\n  medium: 32,\n  small: 24,\n} as const;\n\nexport const treeDataTypes: {\n  readonly [K in TreeOpenChangeData['type'] | TreeNavigationData_unstable['type'] | TreeCheckedChangeData['type']]: K;\n} = {\n  ArrowLeft,\n  ArrowRight,\n  Enter,\n  Click: 'Click',\n  ExpandIconClick: 'ExpandIconClick',\n  End,\n  Home,\n  ArrowUp,\n  ArrowDown,\n  TypeAhead: 'TypeAhead',\n  Change: 'Change',\n};\n"],"names":["treeAvatarSize","treeDataTypes","treeItemLevelToken","medium","small","ArrowLeft","ArrowRight","Enter","Click","ExpandIconClick","End","Home","ArrowUp","ArrowDown","TypeAhead","Change"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAKaA,cAAAA;eAAAA;;IAKAC,aAAAA;eAAAA;;IAPAC,kBAAAA;eAAAA;;;8BAH+D;AAGrE,MAAMA,qBAAqB;AAE3B,MAAMF,iBAAiB;IAC5BG,QAAQ;IACRC,OAAO;AACT;AAEO,MAAMH,gBAET;IACFI,WAAAA,uBAAAA;IACAC,YAAAA,wBAAAA;IACAC,OAAAA,mBAAAA;IACAC,OAAO;IACPC,iBAAiB;IACjBC,KAAAA,iBAAAA;IACAC,MAAAA,kBAAAA;IACAC,SAAAA,qBAAAA;IACAC,WAAAA,uBAAAA;IACAC,WAAW;IACXC,QAAQ;AACV"}

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

@@ -1 +1 @@
-{"version":3,"sources":["treeItemFilter.js"],"sourcesContent":["export const treeItemFilter = (element)=>{\n    return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n};\n"],"names":["treeItemFilter","element","getAttribute","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,iBAAiB,CAACC;IAC3B,OAAOA,QAAQC,YAAY,CAAC,YAAY,aAAaC,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AAC1G"}
+{"version":3,"sources":["treeItemFilter.ts"],"sourcesContent":["export const treeItemFilter = (element: HTMLElement) => {\n  return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n};\n"],"names":["treeItemFilter","element","getAttribute","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"rangeMappings":";;;;;;;;;;;;","mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,iBAAiB,CAACC;IAC7B,OAAOA,QAAQC,YAAY,CAAC,YAAY,aAAaC,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACxG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-tree",
-  "version": "9.7.2",
+  "version": "9.7.3",
   "description": "Tree component for Fluent UI React",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",