Initial commit

node_modules/@fluentui/react-positioning/lib-commonjs/utils/createResizeObserver.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createResizeObserver", {
+    enumerable: true,
+    get: function() {
+        return createResizeObserver;
+    }
+});
+function createResizeObserver(targetWindow, callback) {
+    // https://github.com/jsdom/jsdom/issues/3368
+    // Add the polyfill here so it is not needed for all unit tests that leverage positioning
+    if (process.env.NODE_ENV === 'test') {
+        targetWindow.ResizeObserver = class ResizeObserver {
+            observe() {
+            // do nothing
+            }
+            unobserve() {
+            // do nothing
+            }
+            disconnect() {
+            // do nothing
+            }
+        };
+    }
+    return new targetWindow.ResizeObserver(callback);
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/createResizeObserver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/createResizeObserver.ts"],"sourcesContent":["export function createResizeObserver(targetWindow: Window & typeof globalThis, callback: ResizeObserverCallback) {\n  // https://github.com/jsdom/jsdom/issues/3368\n  // Add the polyfill here so it is not needed for all unit tests that leverage positioning\n  if (process.env.NODE_ENV === 'test') {\n    targetWindow.ResizeObserver = class ResizeObserver {\n      public observe() {\n        // do nothing\n      }\n      public unobserve() {\n        // do nothing\n      }\n      public disconnect() {\n        // do nothing\n      }\n    };\n  }\n\n  return new targetWindow.ResizeObserver(callback);\n}\n"],"names":["createResizeObserver","targetWindow","callback","process","env","NODE_ENV","ResizeObserver","observe","unobserve","disconnect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,qBAAqBC,YAAwC,EAAEC,QAAgC;IAC7G,6CAA6C;IAC7C,yFAAyF;IACzF,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,QAAQ;QACnCJ,aAAaK,cAAc,GAAG,MAAMA;YAC3BC,UAAU;YACf,aAAa;YACf;YACOC,YAAY;YACjB,aAAa;YACf;YACOC,aAAa;YAClB,aAAa;YACf;QACF;IACF;IAEA,OAAO,IAAIR,aAAaK,cAAc,CAACJ;AACzC"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/debounce.js

@@ -0,0 +1,29 @@
+/**
+ * Promise microtask debouncer used by Popper.js v2
+ * This is no longer exported in Floating UI (Popper.js v3)
+ * https://github.com/floating-ui/floating-ui/blob/v2.x/src/utils/debounce.js
+ * @param fn function that will be debounced
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "debounce", {
+    enumerable: true,
+    get: function() {
+        return debounce;
+    }
+});
+function debounce(fn) {
+    let pending;
+    return ()=>{
+        if (!pending) {
+            pending = new Promise((resolve)=>{
+                Promise.resolve().then(()=>{
+                    pending = undefined;
+                    resolve(fn());
+                });
+            });
+        }
+        return pending;
+    };
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/debounce.ts"],"sourcesContent":["/**\n * Promise microtask debouncer used by Popper.js v2\n * This is no longer exported in Floating UI (Popper.js v3)\n * https://github.com/floating-ui/floating-ui/blob/v2.x/src/utils/debounce.js\n * @param fn function that will be debounced\n */\nexport function debounce<T>(fn: Function): () => Promise<T> {\n  let pending: Promise<T> | undefined;\n  return () => {\n    if (!pending) {\n      pending = new Promise<T>(resolve => {\n        Promise.resolve().then(() => {\n          pending = undefined;\n          resolve(fn());\n        });\n      });\n    }\n\n    return pending;\n  };\n}\n"],"names":["debounce","fn","pending","Promise","resolve","then","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;CAKC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,SAAYC,EAAY;IACtC,IAAIC;IACJ,OAAO;QACL,IAAI,CAACA,SAAS;YACZA,UAAU,IAAIC,QAAWC,CAAAA;gBACvBD,QAAQC,OAAO,GAAGC,IAAI,CAAC;oBACrBH,UAAUI;oBACVF,QAAQH;gBACV;YACF;QACF;QAEA,OAAOC;IACT;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/devtools.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "devtoolsCallback", {
+    enumerable: true,
+    get: function() {
+        return devtoolsCallback;
+    }
+});
+const _reactutilities = require("@fluentui/react-utilities");
+const _listScrollParents = require("./listScrollParents");
+const _fromFloatingUIPlacement = require("./fromFloatingUIPlacement");
+const devtoolsCallback = (options)=>(middlewareState)=>{
+        const { elements: { floating, reference } } = middlewareState;
+        const scrollParentsSet = new Set();
+        if ((0, _reactutilities.isHTMLElement)(reference)) {
+            (0, _listScrollParents.listScrollParents)(reference).forEach((scrollParent)=>scrollParentsSet.add(scrollParent));
+        }
+        (0, _listScrollParents.listScrollParents)(floating).forEach((scrollParent)=>scrollParentsSet.add(scrollParent));
+        const flipBoundaries = Array.isArray(options.flipBoundary) ? options.flipBoundary : (0, _reactutilities.isHTMLElement)(options.flipBoundary) ? [
+            options.flipBoundary
+        ] : [];
+        const overflowBoundaries = Array.isArray(options.overflowBoundary) ? options.overflowBoundary : (0, _reactutilities.isHTMLElement)(options.overflowBoundary) ? [
+            options.overflowBoundary
+        ] : [];
+        return {
+            type: 'FluentUIMiddleware',
+            middlewareState,
+            options,
+            initialPlacement: (0, _fromFloatingUIPlacement.fromFloatingUIPlacement)(middlewareState.initialPlacement),
+            placement: (0, _fromFloatingUIPlacement.fromFloatingUIPlacement)(middlewareState.placement),
+            flipBoundaries,
+            overflowBoundaries,
+            scrollParents: Array.from(scrollParentsSet)
+        };
+    };

node_modules/@fluentui/react-positioning/lib-commonjs/utils/devtools.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/devtools.ts"],"sourcesContent":["import type { MiddlewareState } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { isHTMLElement } from '@fluentui/react-utilities';\nimport { listScrollParents } from './listScrollParents';\nimport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\n\nexport const devtoolsCallback = (options: PositioningOptions) => (middlewareState: MiddlewareState) => {\n  const {\n    elements: { floating, reference },\n  } = middlewareState;\n  const scrollParentsSet = new Set<HTMLElement>();\n  if (isHTMLElement(reference)) {\n    listScrollParents(reference).forEach(scrollParent => scrollParentsSet.add(scrollParent));\n  }\n  listScrollParents(floating).forEach(scrollParent => scrollParentsSet.add(scrollParent));\n  const flipBoundaries: HTMLElement[] = Array.isArray(options.flipBoundary)\n    ? options.flipBoundary\n    : isHTMLElement(options.flipBoundary)\n    ? [options.flipBoundary]\n    : [];\n  const overflowBoundaries: HTMLElement[] = Array.isArray(options.overflowBoundary)\n    ? options.overflowBoundary\n    : isHTMLElement(options.overflowBoundary)\n    ? [options.overflowBoundary]\n    : [];\n  return {\n    type: 'FluentUIMiddleware',\n    middlewareState,\n    options,\n    initialPlacement: fromFloatingUIPlacement(middlewareState.initialPlacement),\n    placement: fromFloatingUIPlacement(middlewareState.placement),\n    flipBoundaries,\n    overflowBoundaries,\n    scrollParents: Array.from(scrollParentsSet),\n  } as const;\n};\n"],"names":["devtoolsCallback","options","middlewareState","elements","floating","reference","scrollParentsSet","Set","isHTMLElement","listScrollParents","forEach","scrollParent","add","flipBoundaries","Array","isArray","flipBoundary","overflowBoundaries","overflowBoundary","type","initialPlacement","fromFloatingUIPlacement","placement","scrollParents","from"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMaA;;;eAAAA;;;gCAJiB;mCACI;yCACM;AAEjC,MAAMA,mBAAmB,CAACC,UAAgC,CAACC;QAChE,MAAM,EACJC,UAAU,EAAEC,QAAQ,EAAEC,SAAS,EAAE,EAClC,GAAGH;QACJ,MAAMI,mBAAmB,IAAIC;QAC7B,IAAIC,IAAAA,6BAAa,EAACH,YAAY;YAC5BI,IAAAA,oCAAiB,EAACJ,WAAWK,OAAO,CAACC,CAAAA,eAAgBL,iBAAiBM,GAAG,CAACD;QAC5E;QACAF,IAAAA,oCAAiB,EAACL,UAAUM,OAAO,CAACC,CAAAA,eAAgBL,iBAAiBM,GAAG,CAACD;QACzE,MAAME,iBAAgCC,MAAMC,OAAO,CAACd,QAAQe,YAAY,IACpEf,QAAQe,YAAY,GACpBR,IAAAA,6BAAa,EAACP,QAAQe,YAAY,IAClC;YAACf,QAAQe,YAAY;SAAC,GACtB,EAAE;QACN,MAAMC,qBAAoCH,MAAMC,OAAO,CAACd,QAAQiB,gBAAgB,IAC5EjB,QAAQiB,gBAAgB,GACxBV,IAAAA,6BAAa,EAACP,QAAQiB,gBAAgB,IACtC;YAACjB,QAAQiB,gBAAgB;SAAC,GAC1B,EAAE;QACN,OAAO;YACLC,MAAM;YACNjB;YACAD;YACAmB,kBAAkBC,IAAAA,gDAAuB,EAACnB,gBAAgBkB,gBAAgB;YAC1EE,WAAWD,IAAAA,gDAAuB,EAACnB,gBAAgBoB,SAAS;YAC5DT;YACAI;YACAM,eAAeT,MAAMU,IAAI,CAAClB;QAC5B;IACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/fromFloatingUIPlacement.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fromFloatingUIPlacement", {
+    enumerable: true,
+    get: function() {
+        return fromFloatingUIPlacement;
+    }
+});
+const _parseFloatingUIPlacement = require("./parseFloatingUIPlacement");
+const getPositionMap = ()=>({
+        top: 'above',
+        bottom: 'below',
+        right: 'after',
+        left: 'before'
+    });
+// Floating UI automatically flips alignment
+// https://github.com/floating-ui/floating-ui/issues/1563
+const getAlignmentMap = (position)=>{
+    if (position === 'above' || position === 'below') {
+        return {
+            start: 'start',
+            end: 'end'
+        };
+    }
+    return {
+        start: 'top',
+        end: 'bottom'
+    };
+};
+const fromFloatingUIPlacement = (placement)=>{
+    const { side, alignment: floatingUIAlignment } = (0, _parseFloatingUIPlacement.parseFloatingUIPlacement)(placement);
+    const position = getPositionMap()[side];
+    const alignment = floatingUIAlignment && getAlignmentMap(position)[floatingUIAlignment];
+    return {
+        position,
+        alignment
+    };
+};

node_modules/@fluentui/react-positioning/lib-commonjs/utils/fromFloatingUIPlacement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/fromFloatingUIPlacement.ts"],"sourcesContent":["import type { Side, Alignment as FloatingUIAlignment, Placement } from '@floating-ui/dom';\nimport type { Alignment, Position } from '../types';\nimport { parseFloatingUIPlacement } from './parseFloatingUIPlacement';\n\nconst getPositionMap = (): Record<Side, Position> => ({\n  top: 'above',\n  bottom: 'below',\n  right: 'after',\n  left: 'before',\n});\n\n// Floating UI automatically flips alignment\n// https://github.com/floating-ui/floating-ui/issues/1563\nconst getAlignmentMap = (position: Position): Record<FloatingUIAlignment, Alignment> => {\n  if (position === 'above' || position === 'below') {\n    return {\n      start: 'start',\n      end: 'end',\n    };\n  }\n\n  return {\n    start: 'top',\n    end: 'bottom',\n  };\n};\n\n/**\n * Maps Floating UI placement to positioning values\n * @see positioningHelper.test.ts for expected placement values\n */\nexport const fromFloatingUIPlacement = (placement: Placement): { position: Position; alignment?: Alignment } => {\n  const { side, alignment: floatingUIAlignment } = parseFloatingUIPlacement(placement);\n  const position = getPositionMap()[side];\n  const alignment = floatingUIAlignment && getAlignmentMap(position)[floatingUIAlignment];\n\n  return { position, alignment };\n};\n"],"names":["fromFloatingUIPlacement","getPositionMap","top","bottom","right","left","getAlignmentMap","position","start","end","placement","side","alignment","floatingUIAlignment","parseFloatingUIPlacement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA+BaA;;;eAAAA;;;0CA7B4B;AAEzC,MAAMC,iBAAiB,IAA+B,CAAA;QACpDC,KAAK;QACLC,QAAQ;QACRC,OAAO;QACPC,MAAM;IACR,CAAA;AAEA,4CAA4C;AAC5C,yDAAyD;AACzD,MAAMC,kBAAkB,CAACC;IACvB,IAAIA,aAAa,WAAWA,aAAa,SAAS;QAChD,OAAO;YACLC,OAAO;YACPC,KAAK;QACP;IACF;IAEA,OAAO;QACLD,OAAO;QACPC,KAAK;IACP;AACF;AAMO,MAAMT,0BAA0B,CAACU;IACtC,MAAM,EAAEC,IAAI,EAAEC,WAAWC,mBAAmB,EAAE,GAAGC,IAAAA,kDAAwB,EAACJ;IAC1E,MAAMH,WAAWN,gBAAgB,CAACU,KAAK;IACvC,MAAMC,YAAYC,uBAAuBP,gBAAgBC,SAAS,CAACM,oBAAoB;IAEvF,OAAO;QAAEN;QAAUK;IAAU;AAC/B"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getBoundary.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBoundary", {
+    enumerable: true,
+    get: function() {
+        return getBoundary;
+    }
+});
+const _getScrollParent = require("./getScrollParent");
+function getBoundary(element, boundary) {
+    if (boundary === 'window') {
+        return element === null || element === void 0 ? void 0 : element.ownerDocument.documentElement;
+    }
+    if (boundary === 'clippingParents') {
+        return 'clippingAncestors';
+    }
+    if (boundary === 'scrollParent') {
+        let boundariesNode = (0, _getScrollParent.getScrollParent)(element);
+        if (boundariesNode.nodeName === 'BODY') {
+            boundariesNode = element === null || element === void 0 ? void 0 : element.ownerDocument.documentElement;
+        }
+        return boundariesNode;
+    }
+    return boundary;
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/getBoundary.ts"],"sourcesContent":["import type { Boundary as FloatingUIBoundary } from '@floating-ui/dom';\n\nimport { getScrollParent } from './getScrollParent';\nimport type { PositioningBoundary } from '../types';\n\n/**\n * Allows to mimic a behavior from V1 of Popper and accept `window` and `scrollParent` as strings.\n */\nexport function getBoundary(\n  element: HTMLElement | null,\n  boundary?: PositioningBoundary,\n): FloatingUIBoundary | undefined {\n  if (boundary === 'window') {\n    return element?.ownerDocument!.documentElement;\n  }\n\n  if (boundary === 'clippingParents') {\n    return 'clippingAncestors';\n  }\n\n  if (boundary === 'scrollParent') {\n    let boundariesNode: HTMLElement | undefined = getScrollParent(element);\n\n    if (boundariesNode.nodeName === 'BODY') {\n      boundariesNode = element?.ownerDocument!.documentElement;\n    }\n\n    return boundariesNode;\n  }\n\n  return boundary;\n}\n"],"names":["getBoundary","element","boundary","ownerDocument","documentElement","boundariesNode","getScrollParent","nodeName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;iCANgB;AAMzB,SAASA,YACdC,OAA2B,EAC3BC,QAA8B;IAE9B,IAAIA,aAAa,UAAU;QACzB,OAAOD,oBAAAA,8BAAAA,QAASE,aAAa,CAAEC,eAAe;IAChD;IAEA,IAAIF,aAAa,mBAAmB;QAClC,OAAO;IACT;IAEA,IAAIA,aAAa,gBAAgB;QAC/B,IAAIG,iBAA0CC,IAAAA,gCAAe,EAACL;QAE9D,IAAII,eAAeE,QAAQ,KAAK,QAAQ;YACtCF,iBAAiBJ,oBAAAA,8BAAAA,QAASE,aAAa,CAAEC,eAAe;QAC1D;QAEA,OAAOC;IACT;IAEA,OAAOH;AACT"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getFloatingUIOffset.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getFloatingUIOffset", {
+    enumerable: true,
+    get: function() {
+        return getFloatingUIOffset;
+    }
+});
+const _fromFloatingUIPlacement = require("./fromFloatingUIPlacement");
+function getFloatingUIOffset(rawOffset) {
+    if (!rawOffset) {
+        return rawOffset;
+    }
+    if (typeof rawOffset === 'number' || typeof rawOffset === 'object') {
+        return rawOffset;
+    }
+    return ({ rects: { floating, reference }, placement })=>{
+        const { position, alignment } = (0, _fromFloatingUIPlacement.fromFloatingUIPlacement)(placement);
+        return rawOffset({
+            positionedRect: floating,
+            targetRect: reference,
+            position,
+            alignment
+        });
+    };
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getFloatingUIOffset.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/getFloatingUIOffset.ts"],"sourcesContent":["import type { Offset } from '../types';\nimport type { MiddlewareState } from '@floating-ui/dom';\nimport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\n/**\n * Type taken from Floating UI since they are not exported\n */\nexport type FloatingUIOffsetValue =\n  | number\n  | {\n      /**\n       * The axis that runs along the side of the floating element.\n       * @default 0\n       */\n      mainAxis?: number;\n      /**\n       * The axis that runs along the alignment of the floating element.\n       * @default 0\n       */\n      crossAxis?: number;\n      /**\n       * When set to a number, overrides the `crossAxis` value for aligned\n       * (non-centered/base) placements and works logically. A positive number\n       * will move the floating element in the direction of the opposite edge\n       * to the one that is aligned, while a negative number the reverse.\n       * @default null\n       */\n      alignmentAxis?: number | null;\n    };\n\n/**\n * Type taken from Floating UI since they are not exported\n */\nexport type FloatingUIOffsetFunction = (args: MiddlewareState) => FloatingUIOffsetValue;\n\n/**\n * Shim to transform offset values from this library to Floating UI\n * @param rawOffset Offset from this library\n * @returns An offset value compatible with Floating UI\n */\nexport function getFloatingUIOffset(\n  rawOffset: Offset | undefined,\n): FloatingUIOffsetValue | FloatingUIOffsetFunction | undefined {\n  if (!rawOffset) {\n    return rawOffset;\n  }\n\n  if (typeof rawOffset === 'number' || typeof rawOffset === 'object') {\n    return rawOffset;\n  }\n\n  return ({ rects: { floating, reference }, placement }) => {\n    const { position, alignment } = fromFloatingUIPlacement(placement);\n    return rawOffset({ positionedRect: floating, targetRect: reference, position, alignment });\n  };\n}\n"],"names":["getFloatingUIOffset","rawOffset","rects","floating","reference","placement","position","alignment","fromFloatingUIPlacement","positionedRect","targetRect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAuCgBA;;;eAAAA;;;yCArCwB;AAqCjC,SAASA,oBACdC,SAA6B;IAE7B,IAAI,CAACA,WAAW;QACd,OAAOA;IACT;IAEA,IAAI,OAAOA,cAAc,YAAY,OAAOA,cAAc,UAAU;QAClE,OAAOA;IACT;IAEA,OAAO,CAAC,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,SAAS,EAAE,EAAEC,SAAS,EAAE;QACnD,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAE,GAAGC,IAAAA,gDAAuB,EAACH;QACxD,OAAOJ,UAAU;YAAEQ,gBAAgBN;YAAUO,YAAYN;YAAWE;YAAUC;QAAU;IAC1F;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getReactFiberFromNode.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getReactFiberFromNode", {
+    enumerable: true,
+    get: function() {
+        return getReactFiberFromNode;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+var WorkTag;
+(function(WorkTag) {
+    WorkTag[WorkTag["FunctionComponent"] = 0] = "FunctionComponent";
+    WorkTag[WorkTag["ClassComponent"] = 1] = "ClassComponent";
+    WorkTag[WorkTag["IndeterminateComponent"] = 2] = "IndeterminateComponent";
+    WorkTag[WorkTag["HostRoot"] = 3] = "HostRoot";
+    WorkTag[WorkTag["HostPortal"] = 4] = "HostPortal";
+    WorkTag[WorkTag["HostComponent"] = 5] = "HostComponent";
+    WorkTag[WorkTag["HostText"] = 6] = "HostText";
+    WorkTag[WorkTag["Fragment"] = 7] = "Fragment";
+    WorkTag[WorkTag["Mode"] = 8] = "Mode";
+    WorkTag[WorkTag["ContextConsumer"] = 9] = "ContextConsumer";
+    WorkTag[WorkTag["ContextProvider"] = 10] = "ContextProvider";
+    WorkTag[WorkTag["ForwardRef"] = 11] = "ForwardRef";
+    WorkTag[WorkTag["Profiler"] = 12] = "Profiler";
+    WorkTag[WorkTag["SuspenseComponent"] = 13] = "SuspenseComponent";
+    WorkTag[WorkTag["MemoComponent"] = 14] = "MemoComponent";
+    WorkTag[WorkTag["SimpleMemoComponent"] = 15] = "SimpleMemoComponent";
+    WorkTag[WorkTag["LazyComponent"] = 16] = "LazyComponent";
+    WorkTag[WorkTag["IncompleteClassComponent"] = 17] = "IncompleteClassComponent";
+    WorkTag[WorkTag["DehydratedFragment"] = 18] = "DehydratedFragment";
+    WorkTag[WorkTag["SuspenseListComponent"] = 19] = "SuspenseListComponent";
+    WorkTag[WorkTag["FundamentalComponent"] = 20] = "FundamentalComponent";
+    WorkTag[WorkTag["ScopeComponent"] = 21] = "ScopeComponent";
+})(WorkTag || (WorkTag = {}));
+function getReactFiberFromNode(elm) {
+    if (!elm) {
+        return null;
+    }
+    for(const k in elm){
+        // React 16 uses "__reactInternalInstance$" prefix
+        // React 17 uses "__reactFiber$" prefix
+        // https://github.com/facebook/react/pull/18377
+        if (k.indexOf('__reactInternalInstance$') === 0 || k.indexOf('__reactFiber$') === 0) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return elm[k];
+        }
+    }
+    throw new Error('getReactFiber(): Failed to find a React Fiber on a node');
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getScrollParent.js

@@ -0,0 +1,68 @@
+/**
+ * Returns the parent node or the host of the node argument.
+ * @param node - DOM node.
+ * @returns - parent DOM node.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getParentNode: function() {
+        return getParentNode;
+    },
+    getScrollParent: function() {
+        return getScrollParent;
+    },
+    hasScrollParent: function() {
+        return hasScrollParent;
+    }
+});
+const getParentNode = (node)=>{
+    if (node.nodeName === 'HTML') {
+        return node;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return node.parentNode || node.host;
+};
+/**
+ * Returns CSS styles of the given node.
+ * @param node - DOM node.
+ * @returns - CSS styles.
+ */ const getStyleComputedProperty = (node)=>{
+    var _node_ownerDocument;
+    if (node.nodeType !== 1) {
+        return {};
+    }
+    const window = (_node_ownerDocument = node.ownerDocument) === null || _node_ownerDocument === void 0 ? void 0 : _node_ownerDocument.defaultView;
+    return window.getComputedStyle(node, null);
+};
+const getScrollParent = (node)=>{
+    // Return body, `getScroll` will take care to get the correct `scrollTop` from it
+    const parentNode = node && getParentNode(node);
+    // eslint-disable-next-line
+    if (!parentNode) return document.body;
+    switch(parentNode.nodeName){
+        case 'HTML':
+        case 'BODY':
+            return parentNode.ownerDocument.body;
+        case '#document':
+            return parentNode.body;
+    }
+    // If any of the overflow props is defined for the node then we return it as the parent
+    const { overflow, overflowX, overflowY } = getStyleComputedProperty(parentNode);
+    if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
+        return parentNode;
+    }
+    return getScrollParent(parentNode);
+};
+const hasScrollParent = (node)=>{
+    var _scrollParentElement_ownerDocument;
+    const scrollParentElement = getScrollParent(node);
+    return scrollParentElement ? scrollParentElement !== ((_scrollParentElement_ownerDocument = scrollParentElement.ownerDocument) === null || _scrollParentElement_ownerDocument === void 0 ? void 0 : _scrollParentElement_ownerDocument.body) : false;
+};

node_modules/@fluentui/react-positioning/lib-commonjs/utils/getScrollParent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/getScrollParent.ts"],"sourcesContent":["/**\n * Returns the parent node or the host of the node argument.\n * @param node - DOM node.\n * @returns - parent DOM node.\n */\nexport const getParentNode = (node: HTMLElement): HTMLElement => {\n  if (node.nodeName === 'HTML') {\n    return node;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return node.parentNode || (node as any).host;\n};\n\n/**\n * Returns CSS styles of the given node.\n * @param node - DOM node.\n * @returns - CSS styles.\n */\nconst getStyleComputedProperty = (node: HTMLElement): Partial<CSSStyleDeclaration> => {\n  if (node.nodeType !== 1) {\n    return {};\n  }\n\n  const window = node.ownerDocument?.defaultView;\n  return window!.getComputedStyle(node, null);\n};\n\n/**\n * Returns the first scrollable parent of the given element.\n * @param node - DOM node.\n * @returns - the first scrollable parent.\n */\nexport const getScrollParent = (node: Document | HTMLElement | null): HTMLElement => {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  const parentNode = node && getParentNode(node as HTMLElement);\n  // eslint-disable-next-line\n  if (!parentNode) return document.body;\n\n  switch (parentNode.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return parentNode.ownerDocument!.body;\n    case '#document':\n      return (parentNode as unknown as Document).body;\n  }\n\n  // If any of the overflow props is defined for the node then we return it as the parent\n  const { overflow, overflowX, overflowY } = getStyleComputedProperty(parentNode);\n  if (/(auto|scroll|overlay)/.test(overflow! + overflowY! + overflowX)) {\n    return parentNode;\n  }\n\n  return getScrollParent(parentNode);\n};\n\nexport const hasScrollParent = (node: Document | HTMLElement | null): boolean => {\n  const scrollParentElement: HTMLElement = getScrollParent(node);\n  return scrollParentElement ? scrollParentElement !== scrollParentElement.ownerDocument?.body : false;\n};\n"],"names":["getParentNode","getScrollParent","hasScrollParent","node","nodeName","parentNode","host","getStyleComputedProperty","nodeType","window","ownerDocument","defaultView","getComputedStyle","document","body","overflow","overflowX","overflowY","test","scrollParentElement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;CAIC;;;;;;;;;;;IACYA,aAAa;eAAbA;;IA2BAC,eAAe;eAAfA;;IAuBAC,eAAe;eAAfA;;;AAlDN,MAAMF,gBAAgB,CAACG;IAC5B,IAAIA,KAAKC,QAAQ,KAAK,QAAQ;QAC5B,OAAOD;IACT;IACA,8DAA8D;IAC9D,OAAOA,KAAKE,UAAU,IAAI,AAACF,KAAaG,IAAI;AAC9C;AAEA;;;;CAIC,GACD,MAAMC,2BAA2B,CAACJ;QAKjBA;IAJf,IAAIA,KAAKK,QAAQ,KAAK,GAAG;QACvB,OAAO,CAAC;IACV;IAEA,MAAMC,UAASN,sBAAAA,KAAKO,aAAa,cAAlBP,0CAAAA,oBAAoBQ,WAAW;IAC9C,OAAOF,OAAQG,gBAAgB,CAACT,MAAM;AACxC;AAOO,MAAMF,kBAAkB,CAACE;IAC9B,iFAAiF;IACjF,MAAME,aAAaF,QAAQH,cAAcG;IACzC,2BAA2B;IAC3B,IAAI,CAACE,YAAY,OAAOQ,SAASC,IAAI;IAErC,OAAQT,WAAWD,QAAQ;QACzB,KAAK;QACL,KAAK;YACH,OAAOC,WAAWK,aAAa,CAAEI,IAAI;QACvC,KAAK;YACH,OAAO,AAACT,WAAmCS,IAAI;IACnD;IAEA,uFAAuF;IACvF,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,SAAS,EAAE,GAAGV,yBAAyBF;IACpE,IAAI,wBAAwBa,IAAI,CAACH,WAAYE,YAAaD,YAAY;QACpE,OAAOX;IACT;IAEA,OAAOJ,gBAAgBI;AACzB;AAEO,MAAMH,kBAAkB,CAACC;QAEuBgB;IADrD,MAAMA,sBAAmClB,gBAAgBE;IACzD,OAAOgB,sBAAsBA,0BAAwBA,qCAAAA,oBAAoBT,aAAa,cAAjCS,yDAAAA,mCAAmCL,IAAI,IAAG;AACjG"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/hasAutoFocusFilter.js

@@ -0,0 +1,31 @@
+//
+// Dev utils to detect if nodes have "autoFocus" props.
+//
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hasAutofocusFilter", {
+    enumerable: true,
+    get: function() {
+        return hasAutofocusFilter;
+    }
+});
+const _getReactFiberFromNode = require("./getReactFiberFromNode");
+/**
+ * Detects if a passed HTML node has "autoFocus" prop on a React's fiber. Is needed as React handles autofocus behavior
+ * in React DOM and will not pass "autoFocus" to an actual HTML.
+ *
+ * @param node
+ */ function hasAutofocusProp(node) {
+    // https://github.com/facebook/react/blob/848bb2426e44606e0a55dfe44c7b3ece33772485/packages/react-dom/src/client/ReactDOMHostConfig.js#L157-L166
+    const isAutoFocusableElement = node.nodeName === 'BUTTON' || node.nodeName === 'INPUT' || node.nodeName === 'SELECT' || node.nodeName === 'TEXTAREA';
+    if (isAutoFocusableElement) {
+        var _getReactFiberFromNode1;
+        return !!((_getReactFiberFromNode1 = (0, _getReactFiberFromNode.getReactFiberFromNode)(node)) === null || _getReactFiberFromNode1 === void 0 ? void 0 : _getReactFiberFromNode1.pendingProps.autoFocus);
+    }
+    return false;
+}
+function hasAutofocusFilter(node) {
+    return hasAutofocusProp(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/hasAutoFocusFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/hasAutoFocusFilter.ts"],"sourcesContent":["//\n// Dev utils to detect if nodes have \"autoFocus\" props.\n//\n\nimport { getReactFiberFromNode } from './getReactFiberFromNode';\n\n/**\n * Detects if a passed HTML node has \"autoFocus\" prop on a React's fiber. Is needed as React handles autofocus behavior\n * in React DOM and will not pass \"autoFocus\" to an actual HTML.\n *\n * @param node\n */\nfunction hasAutofocusProp(node: Node): boolean {\n  // https://github.com/facebook/react/blob/848bb2426e44606e0a55dfe44c7b3ece33772485/packages/react-dom/src/client/ReactDOMHostConfig.js#L157-L166\n  const isAutoFocusableElement =\n    node.nodeName === 'BUTTON' ||\n    node.nodeName === 'INPUT' ||\n    node.nodeName === 'SELECT' ||\n    node.nodeName === 'TEXTAREA';\n\n  if (isAutoFocusableElement) {\n    return !!getReactFiberFromNode(node)?.pendingProps.autoFocus;\n  }\n\n  return false;\n}\n\nexport function hasAutofocusFilter(node: Node) {\n  return hasAutofocusProp(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n}\n"],"names":["hasAutofocusFilter","hasAutofocusProp","node","isAutoFocusableElement","nodeName","getReactFiberFromNode","pendingProps","autoFocus","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,EAAE;AACF,uDAAuD;AACvD,EAAE;;;;;+BAyBcA;;;eAAAA;;;uCAvBsB;AAEtC;;;;;CAKC,GACD,SAASC,iBAAiBC,IAAU;IAClC,gJAAgJ;IAChJ,MAAMC,yBACJD,KAAKE,QAAQ,KAAK,YAClBF,KAAKE,QAAQ,KAAK,WAClBF,KAAKE,QAAQ,KAAK,YAClBF,KAAKE,QAAQ,KAAK;IAEpB,IAAID,wBAAwB;YACjBE;QAAT,OAAO,CAAC,GAACA,0BAAAA,IAAAA,4CAAqB,EAACH,mBAAtBG,8CAAAA,wBAA6BC,YAAY,CAACC,SAAS;IAC9D;IAEA,OAAO;AACT;AAEO,SAASP,mBAAmBE,IAAU;IAC3C,OAAOD,iBAAiBC,QAAQM,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACnF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    debounce: function() {
+        return _debounce.debounce;
+    },
+    fromFloatingUIPlacement: function() {
+        return _fromFloatingUIPlacement.fromFloatingUIPlacement;
+    },
+    getBoundary: function() {
+        return _getBoundary.getBoundary;
+    },
+    getParentNode: function() {
+        return _getScrollParent.getParentNode;
+    },
+    getReactFiberFromNode: function() {
+        return _getReactFiberFromNode.getReactFiberFromNode;
+    },
+    getScrollParent: function() {
+        return _getScrollParent.getScrollParent;
+    },
+    hasAutofocusFilter: function() {
+        return _hasAutoFocusFilter.hasAutofocusFilter;
+    },
+    hasScrollParent: function() {
+        return _getScrollParent.hasScrollParent;
+    },
+    mergeArrowOffset: function() {
+        return _mergeArrowOffset.mergeArrowOffset;
+    },
+    normalizeAutoSize: function() {
+        return _normalizeAutoSize.normalizeAutoSize;
+    },
+    parseFloatingUIPlacement: function() {
+        return _parseFloatingUIPlacement.parseFloatingUIPlacement;
+    },
+    resolvePositioningShorthand: function() {
+        return _resolvePositioningShorthand.resolvePositioningShorthand;
+    },
+    toFloatingUIPadding: function() {
+        return _toFloatingUIPadding.toFloatingUIPadding;
+    },
+    toFloatingUIPlacement: function() {
+        return _toFloatingUIPlacement.toFloatingUIPlacement;
+    },
+    toggleScrollListener: function() {
+        return _toggleScrollListener.toggleScrollListener;
+    },
+    useCallbackRef: function() {
+        return _useCallbackRef.useCallbackRef;
+    },
+    writeArrowUpdates: function() {
+        return _writeArrowUpdates.writeArrowUpdates;
+    },
+    writeContainerUpdates: function() {
+        return _writeContainerupdates.writeContainerUpdates;
+    }
+});
+const _parseFloatingUIPlacement = require("./parseFloatingUIPlacement");
+const _getBoundary = require("./getBoundary");
+const _getReactFiberFromNode = require("./getReactFiberFromNode");
+const _getScrollParent = require("./getScrollParent");
+const _mergeArrowOffset = require("./mergeArrowOffset");
+const _toFloatingUIPadding = require("./toFloatingUIPadding");
+const _toFloatingUIPlacement = require("./toFloatingUIPlacement");
+const _fromFloatingUIPlacement = require("./fromFloatingUIPlacement");
+const _resolvePositioningShorthand = require("./resolvePositioningShorthand");
+const _useCallbackRef = require("./useCallbackRef");
+const _debounce = require("./debounce");
+const _toggleScrollListener = require("./toggleScrollListener");
+const _hasAutoFocusFilter = require("./hasAutoFocusFilter");
+const _writeArrowUpdates = require("./writeArrowUpdates");
+const _writeContainerupdates = require("./writeContainerupdates");
+const _normalizeAutoSize = require("./normalizeAutoSize");

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/index.ts"],"sourcesContent":["export { parseFloatingUIPlacement } from './parseFloatingUIPlacement';\nexport { getBoundary } from './getBoundary';\nexport type { Fiber, HookType } from './getReactFiberFromNode';\nexport { getReactFiberFromNode } from './getReactFiberFromNode';\nexport { getParentNode, getScrollParent, hasScrollParent } from './getScrollParent';\nexport { mergeArrowOffset } from './mergeArrowOffset';\nexport { toFloatingUIPadding } from './toFloatingUIPadding';\nexport { toFloatingUIPlacement } from './toFloatingUIPlacement';\nexport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\nexport { resolvePositioningShorthand } from './resolvePositioningShorthand';\nexport { useCallbackRef } from './useCallbackRef';\nexport { debounce } from './debounce';\nexport { toggleScrollListener } from './toggleScrollListener';\nexport { hasAutofocusFilter } from './hasAutoFocusFilter';\nexport { writeArrowUpdates } from './writeArrowUpdates';\nexport { writeContainerUpdates } from './writeContainerupdates';\nexport { normalizeAutoSize } from './normalizeAutoSize';\n"],"names":["debounce","fromFloatingUIPlacement","getBoundary","getParentNode","getReactFiberFromNode","getScrollParent","hasAutofocusFilter","hasScrollParent","mergeArrowOffset","normalizeAutoSize","parseFloatingUIPlacement","resolvePositioningShorthand","toFloatingUIPadding","toFloatingUIPlacement","toggleScrollListener","useCallbackRef","writeArrowUpdates","writeContainerUpdates"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAWSA,QAAQ;eAARA,kBAAQ;;IAHRC,uBAAuB;eAAvBA,gDAAuB;;IAPvBC,WAAW;eAAXA,wBAAW;;IAGXC,aAAa;eAAbA,8BAAa;;IADbC,qBAAqB;eAArBA,4CAAqB;;IACNC,eAAe;eAAfA,gCAAe;;IAS9BC,kBAAkB;eAAlBA,sCAAkB;;IATcC,eAAe;eAAfA,gCAAe;;IAC/CC,gBAAgB;eAAhBA,kCAAgB;;IAWhBC,iBAAiB;eAAjBA,oCAAiB;;IAhBjBC,wBAAwB;eAAxBA,kDAAwB;;IASxBC,2BAA2B;eAA3BA,wDAA2B;;IAH3BC,mBAAmB;eAAnBA,wCAAmB;;IACnBC,qBAAqB;eAArBA,4CAAqB;;IAKrBC,oBAAoB;eAApBA,0CAAoB;;IAFpBC,cAAc;eAAdA,8BAAc;;IAIdC,iBAAiB;eAAjBA,oCAAiB;;IACjBC,qBAAqB;eAArBA,4CAAqB;;;0CAfW;6BACb;uCAEU;iCAC0B;kCAC/B;qCACG;uCACE;yCACE;6CACI;gCACb;0BACN;sCACY;oCACF;mCACD;uCACI;mCACJ"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/listScrollParents.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "listScrollParents", {
+    enumerable: true,
+    get: function() {
+        return listScrollParents;
+    }
+});
+const _getScrollParent = require("./getScrollParent");
+function listScrollParents(node) {
+    const scrollParents = [];
+    let cur = node;
+    while(cur){
+        const scrollParent = (0, _getScrollParent.getScrollParent)(cur);
+        if (node.ownerDocument.body === scrollParent) {
+            scrollParents.push(scrollParent);
+            break;
+        }
+        if (scrollParent.nodeName === 'BODY' && scrollParent !== node.ownerDocument.body) {
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('@fluentui/react-positioning: You are comparing two different documents! This is an unexpected error, please report this as a bug to the Fluent UI team ');
+            }
+            break;
+        }
+        scrollParents.push(scrollParent);
+        cur = scrollParent;
+    }
+    return scrollParents;
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/listScrollParents.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/listScrollParents.ts"],"sourcesContent":["import { getScrollParent } from './getScrollParent';\n\nexport function listScrollParents(node: HTMLElement): HTMLElement[] {\n  const scrollParents: HTMLElement[] = [];\n\n  let cur: HTMLElement | null = node;\n  while (cur) {\n    const scrollParent = getScrollParent(cur);\n\n    if (node.ownerDocument.body === scrollParent) {\n      scrollParents.push(scrollParent);\n      break;\n    }\n\n    if (scrollParent.nodeName === 'BODY' && scrollParent !== node.ownerDocument.body) {\n      if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error(\n          '@fluentui/react-positioning: You are comparing two different documents! This is an unexpected error, please report this as a bug to the Fluent UI team ',\n        );\n      }\n      break;\n    }\n\n    scrollParents.push(scrollParent);\n    cur = scrollParent;\n  }\n\n  return scrollParents;\n}\n"],"names":["listScrollParents","node","scrollParents","cur","scrollParent","getScrollParent","ownerDocument","body","push","nodeName","process","env","NODE_ENV","console","error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEgBA;;;eAAAA;;;iCAFgB;AAEzB,SAASA,kBAAkBC,IAAiB;IACjD,MAAMC,gBAA+B,EAAE;IAEvC,IAAIC,MAA0BF;IAC9B,MAAOE,IAAK;QACV,MAAMC,eAAeC,IAAAA,gCAAe,EAACF;QAErC,IAAIF,KAAKK,aAAa,CAACC,IAAI,KAAKH,cAAc;YAC5CF,cAAcM,IAAI,CAACJ;YACnB;QACF;QAEA,IAAIA,aAAaK,QAAQ,KAAK,UAAUL,iBAAiBH,KAAKK,aAAa,CAACC,IAAI,EAAE;YAChF,IAAIG,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,sCAAsC;gBACtCC,QAAQC,KAAK,CACX;YAEJ;YACA;QACF;QAEAZ,cAAcM,IAAI,CAACJ;QACnBD,MAAMC;IACR;IAEA,OAAOF;AACT"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/mergeArrowOffset.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mergeArrowOffset", {
+    enumerable: true,
+    get: function() {
+        return mergeArrowOffset;
+    }
+});
+function mergeArrowOffset(userOffset, arrowHeight) {
+    if (typeof userOffset === 'number') {
+        return addArrowOffset(userOffset, arrowHeight);
+    }
+    if (typeof userOffset === 'object' && userOffset !== null) {
+        return addArrowOffset(userOffset, arrowHeight);
+    }
+    if (typeof userOffset === 'function') {
+        return (offsetParams)=>{
+            const offset = userOffset(offsetParams);
+            return addArrowOffset(offset, arrowHeight);
+        };
+    }
+    return {
+        mainAxis: arrowHeight
+    };
+}
+const addArrowOffset = (offset, arrowHeight)=>{
+    if (typeof offset === 'number') {
+        return {
+            mainAxis: offset + arrowHeight
+        };
+    }
+    var _offset_mainAxis;
+    return {
+        ...offset,
+        mainAxis: ((_offset_mainAxis = offset.mainAxis) !== null && _offset_mainAxis !== void 0 ? _offset_mainAxis : 0) + arrowHeight
+    };
+};

node_modules/@fluentui/react-positioning/lib-commonjs/utils/mergeArrowOffset.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/mergeArrowOffset.ts"],"sourcesContent":["import type { Offset, OffsetObject } from '../types';\n\n/**\n * Generally when adding an arrow to popper, it's necessary to offset the position of the popper by the\n * height of the arrow. A simple utility to merge a provided offset with an arrow height to return the final offset\n *\n * @internal\n * @param userOffset - The offset provided by the user\n * @param arrowHeight - The height of the arrow in px\n * @returns User offset augmented with arrow height\n */\nexport function mergeArrowOffset(userOffset: Offset | undefined | null, arrowHeight: number): Offset {\n  if (typeof userOffset === 'number') {\n    return addArrowOffset(userOffset, arrowHeight);\n  }\n\n  if (typeof userOffset === 'object' && userOffset !== null) {\n    return addArrowOffset(userOffset, arrowHeight);\n  }\n\n  if (typeof userOffset === 'function') {\n    return offsetParams => {\n      const offset = userOffset(offsetParams);\n      return addArrowOffset(offset, arrowHeight);\n    };\n  }\n\n  return { mainAxis: arrowHeight };\n}\n\nconst addArrowOffset = (offset: OffsetObject | number, arrowHeight: number): OffsetObject => {\n  if (typeof offset === 'number') {\n    return { mainAxis: offset + arrowHeight };\n  }\n\n  return { ...offset, mainAxis: (offset.mainAxis ?? 0) + arrowHeight };\n};\n"],"names":["mergeArrowOffset","userOffset","arrowHeight","addArrowOffset","offsetParams","offset","mainAxis"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWgBA;;;eAAAA;;;AAAT,SAASA,iBAAiBC,UAAqC,EAAEC,WAAmB;IACzF,IAAI,OAAOD,eAAe,UAAU;QAClC,OAAOE,eAAeF,YAAYC;IACpC;IAEA,IAAI,OAAOD,eAAe,YAAYA,eAAe,MAAM;QACzD,OAAOE,eAAeF,YAAYC;IACpC;IAEA,IAAI,OAAOD,eAAe,YAAY;QACpC,OAAOG,CAAAA;YACL,MAAMC,SAASJ,WAAWG;YAC1B,OAAOD,eAAeE,QAAQH;QAChC;IACF;IAEA,OAAO;QAAEI,UAAUJ;IAAY;AACjC;AAEA,MAAMC,iBAAiB,CAACE,QAA+BH;IACrD,IAAI,OAAOG,WAAW,UAAU;QAC9B,OAAO;YAAEC,UAAUD,SAASH;QAAY;IAC1C;QAE+BG;IAA/B,OAAO;QAAE,GAAGA,MAAM;QAAEC,UAAU,AAACD,CAAAA,CAAAA,mBAAAA,OAAOC,QAAQ,cAAfD,8BAAAA,mBAAmB,CAAA,IAAKH;IAAY;AACrE"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/normalizeAutoSize.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeAutoSize", {
+    enumerable: true,
+    get: function() {
+        return normalizeAutoSize;
+    }
+});
+const normalizeAutoSize = (autoSize)=>{
+    switch(autoSize){
+        case 'always':
+        case true:
+            return {
+                applyMaxWidth: true,
+                applyMaxHeight: true
+            };
+        case 'width-always':
+        case 'width':
+            return {
+                applyMaxWidth: true,
+                applyMaxHeight: false
+            };
+        case 'height-always':
+        case 'height':
+            return {
+                applyMaxWidth: false,
+                applyMaxHeight: true
+            };
+        default:
+            return false;
+    }
+};

node_modules/@fluentui/react-positioning/lib-commonjs/utils/normalizeAutoSize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/normalizeAutoSize.ts"],"sourcesContent":["import type { NormalizedAutoSize, PositioningOptions } from '../types';\n\n/**\n * AutoSizes contains many options from historic implementation.\n * Now options 'always'/'height-always'/'width-always' are obsolete.\n * This function maps them to true/'height'/'width'\n */\nexport const normalizeAutoSize = (autoSize?: PositioningOptions['autoSize']): NormalizedAutoSize | false => {\n  switch (autoSize) {\n    case 'always':\n    case true:\n      return {\n        applyMaxWidth: true,\n        applyMaxHeight: true,\n      };\n\n    case 'width-always':\n    case 'width':\n      return {\n        applyMaxWidth: true,\n        applyMaxHeight: false,\n      };\n\n    case 'height-always':\n    case 'height':\n      return {\n        applyMaxWidth: false,\n        applyMaxHeight: true,\n      };\n\n    default:\n      return false;\n  }\n};\n"],"names":["normalizeAutoSize","autoSize","applyMaxWidth","applyMaxHeight"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAOaA;;;eAAAA;;;AAAN,MAAMA,oBAAoB,CAACC;IAChC,OAAQA;QACN,KAAK;QACL,KAAK;YACH,OAAO;gBACLC,eAAe;gBACfC,gBAAgB;YAClB;QAEF,KAAK;QACL,KAAK;YACH,OAAO;gBACLD,eAAe;gBACfC,gBAAgB;YAClB;QAEF,KAAK;QACL,KAAK;YACH,OAAO;gBACLD,eAAe;gBACfC,gBAAgB;YAClB;QAEF;YACE,OAAO;IACX;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/parseFloatingUIPlacement.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseFloatingUIPlacement", {
+    enumerable: true,
+    get: function() {
+        return parseFloatingUIPlacement;
+    }
+});
+function parseFloatingUIPlacement(placement) {
+    const tokens = placement.split('-');
+    return {
+        side: tokens[0],
+        alignment: tokens[1]
+    };
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/parseFloatingUIPlacement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/parseFloatingUIPlacement.ts"],"sourcesContent":["import type { Side, Placement, Alignment } from '@floating-ui/dom';\n\n/**\n * Parses Floating UI placement and returns the different components\n * @param placement - the floating ui placement (i.e. bottom-start)\n *\n * @returns side and alignment components of the placement\n */\nexport function parseFloatingUIPlacement(placement: Placement): { side: Side; alignment: Alignment } {\n  const tokens = placement.split('-');\n  return {\n    side: tokens[0] as Side,\n    alignment: tokens[1] as Alignment,\n  };\n}\n"],"names":["parseFloatingUIPlacement","placement","tokens","split","side","alignment"],"rangeMappings":";;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;AAAT,SAASA,yBAAyBC,SAAoB;IAC3D,MAAMC,SAASD,UAAUE,KAAK,CAAC;IAC/B,OAAO;QACLC,MAAMF,MAAM,CAAC,EAAE;QACfG,WAAWH,MAAM,CAAC,EAAE;IACtB;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/resolvePositioningShorthand.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolvePositioningShorthand", {
+    enumerable: true,
+    get: function() {
+        return resolvePositioningShorthand;
+    }
+});
+// Look up table for shorthand to avoid parsing strings
+const shorthandLookup = {
+    above: {
+        position: 'above',
+        align: 'center'
+    },
+    'above-start': {
+        position: 'above',
+        align: 'start'
+    },
+    'above-end': {
+        position: 'above',
+        align: 'end'
+    },
+    below: {
+        position: 'below',
+        align: 'center'
+    },
+    'below-start': {
+        position: 'below',
+        align: 'start'
+    },
+    'below-end': {
+        position: 'below',
+        align: 'end'
+    },
+    before: {
+        position: 'before',
+        align: 'center'
+    },
+    'before-top': {
+        position: 'before',
+        align: 'top'
+    },
+    'before-bottom': {
+        position: 'before',
+        align: 'bottom'
+    },
+    after: {
+        position: 'after',
+        align: 'center'
+    },
+    'after-top': {
+        position: 'after',
+        align: 'top'
+    },
+    'after-bottom': {
+        position: 'after',
+        align: 'bottom'
+    }
+};
+function resolvePositioningShorthand(shorthand) {
+    if (shorthand === undefined || shorthand === null) {
+        return {};
+    }
+    if (typeof shorthand === 'string') {
+        return shorthandLookup[shorthand];
+    }
+    return shorthand;
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/resolvePositioningShorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/resolvePositioningShorthand.ts"],"sourcesContent":["import type { PositioningShorthand, PositioningShorthandValue, PositioningProps } from '../types';\n\n// Look up table for shorthand to avoid parsing strings\nconst shorthandLookup: Record<PositioningShorthandValue, Pick<PositioningProps, 'position' | 'align'>> = {\n  above: { position: 'above', align: 'center' },\n  'above-start': { position: 'above', align: 'start' },\n  'above-end': { position: 'above', align: 'end' },\n  below: { position: 'below', align: 'center' },\n  'below-start': { position: 'below', align: 'start' },\n  'below-end': { position: 'below', align: 'end' },\n  before: { position: 'before', align: 'center' },\n  'before-top': { position: 'before', align: 'top' },\n  'before-bottom': { position: 'before', align: 'bottom' },\n  after: { position: 'after', align: 'center' },\n  'after-top': { position: 'after', align: 'top' },\n  'after-bottom': { position: 'after', align: 'bottom' },\n};\n\nexport function resolvePositioningShorthand(\n  shorthand: PositioningShorthand | undefined | null,\n): Readonly<PositioningProps> {\n  if (shorthand === undefined || shorthand === null) {\n    return {};\n  }\n\n  if (typeof shorthand === 'string') {\n    return shorthandLookup[shorthand];\n  }\n\n  return shorthand as Readonly<PositioningProps>;\n}\n"],"names":["resolvePositioningShorthand","shorthandLookup","above","position","align","below","before","after","shorthand","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAkBgBA;;;eAAAA;;;AAhBhB,uDAAuD;AACvD,MAAMC,kBAAmG;IACvGC,OAAO;QAAEC,UAAU;QAASC,OAAO;IAAS;IAC5C,eAAe;QAAED,UAAU;QAASC,OAAO;IAAQ;IACnD,aAAa;QAAED,UAAU;QAASC,OAAO;IAAM;IAC/CC,OAAO;QAAEF,UAAU;QAASC,OAAO;IAAS;IAC5C,eAAe;QAAED,UAAU;QAASC,OAAO;IAAQ;IACnD,aAAa;QAAED,UAAU;QAASC,OAAO;IAAM;IAC/CE,QAAQ;QAAEH,UAAU;QAAUC,OAAO;IAAS;IAC9C,cAAc;QAAED,UAAU;QAAUC,OAAO;IAAM;IACjD,iBAAiB;QAAED,UAAU;QAAUC,OAAO;IAAS;IACvDG,OAAO;QAAEJ,UAAU;QAASC,OAAO;IAAS;IAC5C,aAAa;QAAED,UAAU;QAASC,OAAO;IAAM;IAC/C,gBAAgB;QAAED,UAAU;QAASC,OAAO;IAAS;AACvD;AAEO,SAASJ,4BACdQ,SAAkD;IAElD,IAAIA,cAAcC,aAAaD,cAAc,MAAM;QACjD,OAAO,CAAC;IACV;IAEA,IAAI,OAAOA,cAAc,UAAU;QACjC,OAAOP,eAAe,CAACO,UAAU;IACnC;IAEA,OAAOA;AACT"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/toFloatingUIPadding.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "toFloatingUIPadding", {
+    enumerable: true,
+    get: function() {
+        return toFloatingUIPadding;
+    }
+});
+function toFloatingUIPadding(padding, isRtl) {
+    if (typeof padding === 'number') {
+        return padding;
+    }
+    const { start, end, ...verticalPadding } = padding;
+    const paddingObject = verticalPadding;
+    const left = isRtl ? 'end' : 'start';
+    const right = isRtl ? 'start' : 'end';
+    // assign properties explicitly since undefined values are actually handled by floating UI
+    // TODO create floating UI issue
+    if (padding[left]) {
+        paddingObject.left = padding[left];
+    }
+    if (padding[right]) {
+        paddingObject.right = padding[right];
+    }
+    return paddingObject;
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/toFloatingUIPadding.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/toFloatingUIPadding.ts"],"sourcesContent":["import type { SideObject } from '@floating-ui/dom';\nimport { PositioningOptions } from '../types';\n\nexport function toFloatingUIPadding(\n  padding: NonNullable<PositioningOptions['overflowBoundaryPadding']>,\n  isRtl: boolean,\n): number | Partial<SideObject> {\n  if (typeof padding === 'number') {\n    return padding;\n  }\n\n  const { start, end, ...verticalPadding } = padding;\n\n  const paddingObject: Partial<SideObject> = verticalPadding;\n\n  const left = isRtl ? 'end' : 'start';\n  const right = isRtl ? 'start' : 'end';\n\n  // assign properties explicitly since undefined values are actually handled by floating UI\n  // TODO create floating UI issue\n  if (padding[left]) {\n    paddingObject.left = padding[left];\n  }\n\n  if (padding[right]) {\n    paddingObject.right = padding[right];\n  }\n\n  return paddingObject;\n}\n"],"names":["toFloatingUIPadding","padding","isRtl","start","end","verticalPadding","paddingObject","left","right"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;AAAT,SAASA,oBACdC,OAAmE,EACnEC,KAAc;IAEd,IAAI,OAAOD,YAAY,UAAU;QAC/B,OAAOA;IACT;IAEA,MAAM,EAAEE,KAAK,EAAEC,GAAG,EAAE,GAAGC,iBAAiB,GAAGJ;IAE3C,MAAMK,gBAAqCD;IAE3C,MAAME,OAAOL,QAAQ,QAAQ;IAC7B,MAAMM,QAAQN,QAAQ,UAAU;IAEhC,0FAA0F;IAC1F,gCAAgC;IAChC,IAAID,OAAO,CAACM,KAAK,EAAE;QACjBD,cAAcC,IAAI,GAAGN,OAAO,CAACM,KAAK;IACpC;IAEA,IAAIN,OAAO,CAACO,MAAM,EAAE;QAClBF,cAAcE,KAAK,GAAGP,OAAO,CAACO,MAAM;IACtC;IAEA,OAAOF;AACT"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/toFloatingUIPlacement.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "toFloatingUIPlacement", {
+    enumerable: true,
+    get: function() {
+        return toFloatingUIPlacement;
+    }
+});
+const getPositionMap = (rtl)=>({
+        above: 'top',
+        below: 'bottom',
+        before: rtl ? 'right' : 'left',
+        after: rtl ? 'left' : 'right'
+    });
+// Floating UI automatically flips alignment
+// https://github.com/floating-ui/floating-ui/issues/1563
+const getAlignmentMap = ()=>({
+        start: 'start',
+        end: 'end',
+        top: 'start',
+        bottom: 'end',
+        center: undefined
+    });
+const shouldAlignToCenter = (p, a)=>{
+    const positionedVertically = p === 'above' || p === 'below';
+    const alignedVertically = a === 'top' || a === 'bottom';
+    return positionedVertically && alignedVertically || !positionedVertically && !alignedVertically;
+};
+const toFloatingUIPlacement = (align, position, rtl)=>{
+    const alignment = shouldAlignToCenter(position, align) ? 'center' : align;
+    const computedPosition = position && getPositionMap(rtl)[position];
+    const computedAlignment = alignment && getAlignmentMap()[alignment];
+    if (computedPosition && computedAlignment) {
+        return `${computedPosition}-${computedAlignment}`;
+    }
+    return computedPosition;
+};

node_modules/@fluentui/react-positioning/lib-commonjs/utils/toFloatingUIPlacement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/toFloatingUIPlacement.ts"],"sourcesContent":["import type { Placement, Side, Alignment as FloatingUIAlignment } from '@floating-ui/dom';\nimport type { Alignment, Position } from '../types';\n\ntype PlacementPosition = Side;\ntype PlacementAlign = FloatingUIAlignment;\n\nconst getPositionMap = (rtl?: boolean): Record<Position, PlacementPosition> => ({\n  above: 'top',\n  below: 'bottom',\n  before: rtl ? 'right' : 'left',\n  after: rtl ? 'left' : 'right',\n});\n\n// Floating UI automatically flips alignment\n// https://github.com/floating-ui/floating-ui/issues/1563\nconst getAlignmentMap = (): Record<Alignment, PlacementAlign | undefined> => ({\n  start: 'start',\n  end: 'end',\n  top: 'start',\n  bottom: 'end',\n  center: undefined,\n});\n\nconst shouldAlignToCenter = (p?: Position, a?: Alignment): boolean => {\n  const positionedVertically = p === 'above' || p === 'below';\n  const alignedVertically = a === 'top' || a === 'bottom';\n\n  return (positionedVertically && alignedVertically) || (!positionedVertically && !alignedVertically);\n};\n\n/**\n * Maps internal positioning values to Floating UI placement\n * @see positioningHelper.test.ts for expected placement values\n */\nexport const toFloatingUIPlacement = (align?: Alignment, position?: Position, rtl?: boolean): Placement | undefined => {\n  const alignment = shouldAlignToCenter(position, align) ? 'center' : align;\n\n  const computedPosition = position && getPositionMap(rtl)[position];\n  const computedAlignment = alignment && getAlignmentMap()[alignment];\n\n  if (computedPosition && computedAlignment) {\n    return `${computedPosition}-${computedAlignment}` as Placement;\n  }\n\n  return computedPosition;\n};\n"],"names":["toFloatingUIPlacement","getPositionMap","rtl","above","below","before","after","getAlignmentMap","start","end","top","bottom","center","undefined","shouldAlignToCenter","p","a","positionedVertically","alignedVertically","align","position","alignment","computedPosition","computedAlignment"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAkCaA;;;eAAAA;;;AA5Bb,MAAMC,iBAAiB,CAACC,MAAwD,CAAA;QAC9EC,OAAO;QACPC,OAAO;QACPC,QAAQH,MAAM,UAAU;QACxBI,OAAOJ,MAAM,SAAS;IACxB,CAAA;AAEA,4CAA4C;AAC5C,yDAAyD;AACzD,MAAMK,kBAAkB,IAAsD,CAAA;QAC5EC,OAAO;QACPC,KAAK;QACLC,KAAK;QACLC,QAAQ;QACRC,QAAQC;IACV,CAAA;AAEA,MAAMC,sBAAsB,CAACC,GAAcC;IACzC,MAAMC,uBAAuBF,MAAM,WAAWA,MAAM;IACpD,MAAMG,oBAAoBF,MAAM,SAASA,MAAM;IAE/C,OAAO,AAACC,wBAAwBC,qBAAuB,CAACD,wBAAwB,CAACC;AACnF;AAMO,MAAMlB,wBAAwB,CAACmB,OAAmBC,UAAqBlB;IAC5E,MAAMmB,YAAYP,oBAAoBM,UAAUD,SAAS,WAAWA;IAEpE,MAAMG,mBAAmBF,YAAYnB,eAAeC,IAAI,CAACkB,SAAS;IAClE,MAAMG,oBAAoBF,aAAad,iBAAiB,CAACc,UAAU;IAEnE,IAAIC,oBAAoBC,mBAAmB;QACzC,OAAO,CAAC,EAAED,iBAAiB,CAAC,EAAEC,kBAAkB,CAAC;IACnD;IAEA,OAAOD;AACT"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/toggleScrollListener.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "toggleScrollListener", {
+    enumerable: true,
+    get: function() {
+        return toggleScrollListener;
+    }
+});
+const _reactutilities = require("@fluentui/react-utilities");
+const _getScrollParent = require("./getScrollParent");
+function toggleScrollListener(next, prev, handler) {
+    if (next === prev) {
+        return;
+    }
+    if ((0, _reactutilities.isHTMLElement)(prev)) {
+        const prevScrollParent = (0, _getScrollParent.getScrollParent)(prev);
+        prevScrollParent.removeEventListener('scroll', handler);
+    }
+    if ((0, _reactutilities.isHTMLElement)(next)) {
+        const scrollParent = (0, _getScrollParent.getScrollParent)(next);
+        scrollParent.addEventListener('scroll', handler);
+    }
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/toggleScrollListener.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/toggleScrollListener.ts"],"sourcesContent":["import { isHTMLElement } from '@fluentui/react-utilities';\nimport type { PositioningVirtualElement } from '../types';\nimport { getScrollParent } from './getScrollParent';\n\n/**\n * Toggles event listeners for scroll parent.\n * Cleans up the event listeners for the previous element and adds them for the new scroll parent.\n * @param next Next element\n * @param prev Previous element\n */\nexport function toggleScrollListener(\n  next: HTMLElement | PositioningVirtualElement | null,\n  prev: HTMLElement | PositioningVirtualElement | null,\n  handler: EventListener,\n) {\n  if (next === prev) {\n    return;\n  }\n\n  if (isHTMLElement(prev)) {\n    const prevScrollParent = getScrollParent(prev);\n    prevScrollParent.removeEventListener('scroll', handler);\n  }\n  if (isHTMLElement(next)) {\n    const scrollParent = getScrollParent(next);\n    scrollParent.addEventListener('scroll', handler);\n  }\n}\n"],"names":["toggleScrollListener","next","prev","handler","isHTMLElement","prevScrollParent","getScrollParent","removeEventListener","scrollParent","addEventListener"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUgBA;;;eAAAA;;;gCAVc;iCAEE;AAQzB,SAASA,qBACdC,IAAoD,EACpDC,IAAoD,EACpDC,OAAsB;IAEtB,IAAIF,SAASC,MAAM;QACjB;IACF;IAEA,IAAIE,IAAAA,6BAAa,EAACF,OAAO;QACvB,MAAMG,mBAAmBC,IAAAA,gCAAe,EAACJ;QACzCG,iBAAiBE,mBAAmB,CAAC,UAAUJ;IACjD;IACA,IAAIC,IAAAA,6BAAa,EAACH,OAAO;QACvB,MAAMO,eAAeF,IAAAA,gCAAe,EAACL;QACrCO,aAAaC,gBAAgB,CAAC,UAAUN;IAC1C;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/useCallbackRef.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useCallbackRef", {
+    enumerable: true,
+    get: function() {
+        return useCallbackRef;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+function useCallbackRef(initialValue, callback, skipInitialResolve) {
+    const isFirst = _react.useRef(true);
+    const [ref] = _react.useState(()=>({
+            // value
+            value: initialValue,
+            // last callback
+            callback,
+            // "memoized" public interface
+            facade: {
+                get current () {
+                    return ref.value;
+                },
+                set current (value){
+                    const last = ref.value;
+                    if (last !== value) {
+                        ref.value = value;
+                        if (skipInitialResolve && isFirst.current) {
+                            return;
+                        }
+                        ref.callback(value, last);
+                    }
+                }
+            }
+        }));
+    (0, _reactutilities.useIsomorphicLayoutEffect)(()=>{
+        isFirst.current = false;
+    }, []);
+    // update callback
+    ref.callback = callback;
+    return ref.facade;
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/useCallbackRef.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/useCallbackRef.ts"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\n\n/**\n * Creates a MutableRef with ref change callback. Is useful as React.useRef() doesn't notify you when its content\n * changes and mutating the .current property doesn't cause a re-render. An opt-out will be use a callback ref via\n * React.useState(), but it will cause re-renders always.\n *\n * https://reactjs.org/docs/hooks-reference.html#useref\n * https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref\n *\n * @param initialValue - initial ref value\n * @param callback - a callback to run when value changes\n * @param skipInitialResolve - a flag to skip an initial ref report\n *\n * @example\n * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);\n * ref.current = 1;\n * // prints 0 -> 1\n */\nexport function useCallbackRef<T>(\n  initialValue: T | null,\n  callback: (newValue: T | null, lastValue: T | null) => void,\n  skipInitialResolve?: boolean,\n): React.MutableRefObject<T | null> {\n  const isFirst = React.useRef(true);\n  const [ref] = React.useState(() => ({\n    // value\n    value: initialValue,\n    // last callback\n    callback,\n    // \"memoized\" public interface\n    facade: {\n      get current() {\n        return ref.value;\n      },\n      set current(value) {\n        const last = ref.value;\n\n        if (last !== value) {\n          ref.value = value;\n\n          if (skipInitialResolve && isFirst.current) {\n            return;\n          }\n\n          ref.callback(value, last);\n        }\n      },\n    },\n  }));\n\n  useIsomorphicLayoutEffect(() => {\n    isFirst.current = false;\n  }, []);\n\n  // update callback\n  ref.callback = callback;\n\n  return ref.facade;\n}\n"],"names":["useCallbackRef","initialValue","callback","skipInitialResolve","isFirst","React","useRef","ref","useState","value","facade","current","last","useIsomorphicLayoutEffect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAoBgBA;;;eAAAA;;;;iEApBO;gCACmB;AAmBnC,SAASA,eACdC,YAAsB,EACtBC,QAA2D,EAC3DC,kBAA4B;IAE5B,MAAMC,UAAUC,OAAMC,MAAM,CAAC;IAC7B,MAAM,CAACC,IAAI,GAAGF,OAAMG,QAAQ,CAAC,IAAO,CAAA;YAClC,QAAQ;YACRC,OAAOR;YACP,gBAAgB;YAChBC;YACA,8BAA8B;YAC9BQ,QAAQ;gBACN,IAAIC,WAAU;oBACZ,OAAOJ,IAAIE,KAAK;gBAClB;gBACA,IAAIE,SAAQF,MAAO;oBACjB,MAAMG,OAAOL,IAAIE,KAAK;oBAEtB,IAAIG,SAASH,OAAO;wBAClBF,IAAIE,KAAK,GAAGA;wBAEZ,IAAIN,sBAAsBC,QAAQO,OAAO,EAAE;4BACzC;wBACF;wBAEAJ,IAAIL,QAAQ,CAACO,OAAOG;oBACtB;gBACF;YACF;QACF,CAAA;IAEAC,IAAAA,yCAAyB,EAAC;QACxBT,QAAQO,OAAO,GAAG;IACpB,GAAG,EAAE;IAEL,kBAAkB;IAClBJ,IAAIL,QAAQ,GAAGA;IAEf,OAAOK,IAAIG,MAAM;AACnB"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/writeArrowUpdates.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeArrowUpdates", {
+    enumerable: true,
+    get: function() {
+        return writeArrowUpdates;
+    }
+});
+function writeArrowUpdates(options) {
+    const { arrow, middlewareData } = options;
+    if (!middlewareData.arrow || !arrow) {
+        return;
+    }
+    const { x: arrowX, y: arrowY } = middlewareData.arrow;
+    Object.assign(arrow.style, {
+        left: arrowX !== null && arrowX !== undefined ? `${arrowX}px` : '',
+        top: arrowY !== null && arrowY !== undefined ? `${arrowY}px` : ''
+    });
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/writeArrowUpdates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/writeArrowUpdates.ts"],"sourcesContent":["import { MiddlewareData } from '@floating-ui/dom';\n\n/**\n * Writes all DOM element updates after position is computed\n */\nexport function writeArrowUpdates(options: { arrow: HTMLElement | null; middlewareData: MiddlewareData }) {\n  const { arrow, middlewareData } = options;\n  if (!middlewareData.arrow || !arrow) {\n    return;\n  }\n\n  const { x: arrowX, y: arrowY } = middlewareData.arrow;\n\n  Object.assign(arrow.style, {\n    left: arrowX !== null && arrowX !== undefined ? `${arrowX}px` : '',\n    top: arrowY !== null && arrowY !== undefined ? `${arrowY}px` : '',\n  });\n}\n"],"names":["writeArrowUpdates","options","arrow","middlewareData","x","arrowX","y","arrowY","Object","assign","style","left","undefined","top"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKgBA;;;eAAAA;;;AAAT,SAASA,kBAAkBC,OAAsE;IACtG,MAAM,EAAEC,KAAK,EAAEC,cAAc,EAAE,GAAGF;IAClC,IAAI,CAACE,eAAeD,KAAK,IAAI,CAACA,OAAO;QACnC;IACF;IAEA,MAAM,EAAEE,GAAGC,MAAM,EAAEC,GAAGC,MAAM,EAAE,GAAGJ,eAAeD,KAAK;IAErDM,OAAOC,MAAM,CAACP,MAAMQ,KAAK,EAAE;QACzBC,MAAMN,WAAW,QAAQA,WAAWO,YAAY,CAAC,EAAEP,OAAO,EAAE,CAAC,GAAG;QAChEQ,KAAKN,WAAW,QAAQA,WAAWK,YAAY,CAAC,EAAEL,OAAO,EAAE,CAAC,GAAG;IACjE;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/writeContainerupdates.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeContainerUpdates", {
+    enumerable: true,
+    get: function() {
+        return writeContainerUpdates;
+    }
+});
+const _constants = require("../constants");
+function writeContainerUpdates(options) {
+    var _middlewareData_hide, _middlewareData_hide1, _container_ownerDocument_defaultView;
+    const { container, placement, middlewareData, strategy, lowPPI, coordinates, useTransform = true } = options;
+    if (!container) {
+        return;
+    }
+    container.setAttribute(_constants.DATA_POSITIONING_PLACEMENT, placement);
+    container.removeAttribute(_constants.DATA_POSITIONING_INTERSECTING);
+    if (middlewareData.intersectionObserver.intersecting) {
+        container.setAttribute(_constants.DATA_POSITIONING_INTERSECTING, '');
+    }
+    container.removeAttribute(_constants.DATA_POSITIONING_ESCAPED);
+    if ((_middlewareData_hide = middlewareData.hide) === null || _middlewareData_hide === void 0 ? void 0 : _middlewareData_hide.escaped) {
+        container.setAttribute(_constants.DATA_POSITIONING_ESCAPED, '');
+    }
+    container.removeAttribute(_constants.DATA_POSITIONING_HIDDEN);
+    if ((_middlewareData_hide1 = middlewareData.hide) === null || _middlewareData_hide1 === void 0 ? void 0 : _middlewareData_hide1.referenceHidden) {
+        container.setAttribute(_constants.DATA_POSITIONING_HIDDEN, '');
+    }
+    // Round so that the coordinates land on device pixels.
+    // This prevents blurriness in cases where the browser doesn't apply pixel snapping, such as when other effects like
+    // `backdrop-filter: blur()` are applied to the container, and the browser is zoomed in.
+    // See https://github.com/microsoft/fluentui/issues/26764 for more info.
+    const devicePixelRatio = ((_container_ownerDocument_defaultView = container.ownerDocument.defaultView) === null || _container_ownerDocument_defaultView === void 0 ? void 0 : _container_ownerDocument_defaultView.devicePixelRatio) || 1;
+    const x = Math.round(coordinates.x * devicePixelRatio) / devicePixelRatio;
+    const y = Math.round(coordinates.y * devicePixelRatio) / devicePixelRatio;
+    Object.assign(container.style, {
+        position: strategy
+    });
+    if (useTransform) {
+        Object.assign(container.style, {
+            transform: lowPPI ? `translate(${x}px, ${y}px)` : `translate3d(${x}px, ${y}px, 0)`
+        });
+        return;
+    }
+    Object.assign(container.style, {
+        left: `${x}px`,
+        top: `${y}px`
+    });
+}

node_modules/@fluentui/react-positioning/lib-commonjs/utils/writeContainerupdates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/writeContainerupdates.ts"],"sourcesContent":["import type { Placement, MiddlewareData, Strategy, Coords } from '@floating-ui/dom';\nimport {\n  DATA_POSITIONING_ESCAPED,\n  DATA_POSITIONING_HIDDEN,\n  DATA_POSITIONING_INTERSECTING,\n  DATA_POSITIONING_PLACEMENT,\n} from '../constants';\n\n/**\n * Writes all container element position updates after the position is computed\n */\nexport function writeContainerUpdates(options: {\n  container: HTMLElement | null;\n  placement: Placement;\n  middlewareData: MiddlewareData;\n  /**\n   * Layer acceleration can disable subpixel rendering which causes slightly\n   * blurry text on low PPI displays, so we want to use 2D transforms\n   * instead\n   */\n  lowPPI: boolean;\n  strategy: Strategy;\n  coordinates: Coords;\n  useTransform?: boolean;\n}) {\n  const { container, placement, middlewareData, strategy, lowPPI, coordinates, useTransform = true } = options;\n  if (!container) {\n    return;\n  }\n  container.setAttribute(DATA_POSITIONING_PLACEMENT, placement);\n  container.removeAttribute(DATA_POSITIONING_INTERSECTING);\n  if (middlewareData.intersectionObserver.intersecting) {\n    container.setAttribute(DATA_POSITIONING_INTERSECTING, '');\n  }\n\n  container.removeAttribute(DATA_POSITIONING_ESCAPED);\n  if (middlewareData.hide?.escaped) {\n    container.setAttribute(DATA_POSITIONING_ESCAPED, '');\n  }\n\n  container.removeAttribute(DATA_POSITIONING_HIDDEN);\n  if (middlewareData.hide?.referenceHidden) {\n    container.setAttribute(DATA_POSITIONING_HIDDEN, '');\n  }\n\n  // Round so that the coordinates land on device pixels.\n  // This prevents blurriness in cases where the browser doesn't apply pixel snapping, such as when other effects like\n  // `backdrop-filter: blur()` are applied to the container, and the browser is zoomed in.\n  // See https://github.com/microsoft/fluentui/issues/26764 for more info.\n  const devicePixelRatio = container.ownerDocument.defaultView?.devicePixelRatio || 1;\n  const x = Math.round(coordinates.x * devicePixelRatio) / devicePixelRatio;\n  const y = Math.round(coordinates.y * devicePixelRatio) / devicePixelRatio;\n\n  Object.assign(container.style, {\n    position: strategy,\n  });\n\n  if (useTransform) {\n    Object.assign(container.style, {\n      transform: lowPPI ? `translate(${x}px, ${y}px)` : `translate3d(${x}px, ${y}px, 0)`,\n    });\n    return;\n  }\n\n  Object.assign(container.style, {\n    left: `${x}px`,\n    top: `${y}px`,\n  });\n}\n"],"names":["writeContainerUpdates","options","middlewareData","container","placement","strategy","lowPPI","coordinates","useTransform","setAttribute","DATA_POSITIONING_PLACEMENT","removeAttribute","DATA_POSITIONING_INTERSECTING","intersectionObserver","intersecting","DATA_POSITIONING_ESCAPED","hide","escaped","DATA_POSITIONING_HIDDEN","referenceHidden","devicePixelRatio","ownerDocument","defaultView","x","Math","round","y","Object","assign","style","position","transform","left","top"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWgBA;;;eAAAA;;;2BALT;AAKA,SAASA,sBAAsBC,OAarC;QAYKC,sBAKAA,uBAQqBC;IAxBzB,MAAM,EAAEA,SAAS,EAAEC,SAAS,EAAEF,cAAc,EAAEG,QAAQ,EAAEC,MAAM,EAAEC,WAAW,EAAEC,eAAe,IAAI,EAAE,GAAGP;IACrG,IAAI,CAACE,WAAW;QACd;IACF;IACAA,UAAUM,YAAY,CAACC,qCAA0B,EAAEN;IACnDD,UAAUQ,eAAe,CAACC,wCAA6B;IACvD,IAAIV,eAAeW,oBAAoB,CAACC,YAAY,EAAE;QACpDX,UAAUM,YAAY,CAACG,wCAA6B,EAAE;IACxD;IAEAT,UAAUQ,eAAe,CAACI,mCAAwB;IAClD,KAAIb,uBAAAA,eAAec,IAAI,cAAnBd,2CAAAA,qBAAqBe,OAAO,EAAE;QAChCd,UAAUM,YAAY,CAACM,mCAAwB,EAAE;IACnD;IAEAZ,UAAUQ,eAAe,CAACO,kCAAuB;IACjD,KAAIhB,wBAAAA,eAAec,IAAI,cAAnBd,4CAAAA,sBAAqBiB,eAAe,EAAE;QACxChB,UAAUM,YAAY,CAACS,kCAAuB,EAAE;IAClD;IAEA,uDAAuD;IACvD,oHAAoH;IACpH,wFAAwF;IACxF,wEAAwE;IACxE,MAAME,mBAAmBjB,EAAAA,uCAAAA,UAAUkB,aAAa,CAACC,WAAW,cAAnCnB,2DAAAA,qCAAqCiB,gBAAgB,KAAI;IAClF,MAAMG,IAAIC,KAAKC,KAAK,CAAClB,YAAYgB,CAAC,GAAGH,oBAAoBA;IACzD,MAAMM,IAAIF,KAAKC,KAAK,CAAClB,YAAYmB,CAAC,GAAGN,oBAAoBA;IAEzDO,OAAOC,MAAM,CAACzB,UAAU0B,KAAK,EAAE;QAC7BC,UAAUzB;IACZ;IAEA,IAAIG,cAAc;QAChBmB,OAAOC,MAAM,CAACzB,UAAU0B,KAAK,EAAE;YAC7BE,WAAWzB,SAAS,CAAC,UAAU,EAAEiB,EAAE,IAAI,EAAEG,EAAE,GAAG,CAAC,GAAG,CAAC,YAAY,EAAEH,EAAE,IAAI,EAAEG,EAAE,MAAM,CAAC;QACpF;QACA;IACF;IAEAC,OAAOC,MAAM,CAACzB,UAAU0B,KAAK,EAAE;QAC7BG,MAAM,CAAC,EAAET,EAAE,EAAE,CAAC;QACdU,KAAK,CAAC,EAAEP,EAAE,EAAE,CAAC;IACf;AACF"}