const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));

[7500] Fix | Delete

[7501] Fix | Delete

// Make `computeCoords` start from the right place.

[7502] Fix | Delete

if (placement !== currentPlacement) {

[7503] Fix | Delete

return {

[7504] Fix | Delete

reset: {

[7505] Fix | Delete

placement: placements$1[0]

[7506] Fix | Delete

}

[7507] Fix | Delete

};

[7508] Fix | Delete

}

[7509] Fix | Delete

const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];

[7510] Fix | Delete

const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {

[7511] Fix | Delete

placement: currentPlacement,

[7512] Fix | Delete

overflows: currentOverflows

[7513] Fix | Delete

}];

[7514] Fix | Delete

const nextPlacement = placements$1[currentIndex + 1];

[7515] Fix | Delete

[7516] Fix | Delete

// There are more placements to check.

[7517] Fix | Delete

if (nextPlacement) {

[7518] Fix | Delete

return {

[7519] Fix | Delete

data: {

[7520] Fix | Delete

index: currentIndex + 1,

[7521] Fix | Delete

overflows: allOverflows

[7522] Fix | Delete

},

[7523] Fix | Delete

reset: {

[7524] Fix | Delete

placement: nextPlacement

[7525] Fix | Delete

}

[7526] Fix | Delete

};

[7527] Fix | Delete

}

[7528] Fix | Delete

const placementsSortedByMostSpace = allOverflows.map(d => {

[7529] Fix | Delete

const alignment = getAlignment(d.placement);

[7530] Fix | Delete

return [d.placement, alignment && crossAxis ?

[7531] Fix | Delete

// Check along the mainAxis and main crossAxis side.

[7532] Fix | Delete

d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :

[7533] Fix | Delete

// Check only the mainAxis.

[7534] Fix | Delete

d.overflows[0], d.overflows];

[7535] Fix | Delete

}).sort((a, b) => a[1] - b[1]);

[7536] Fix | Delete

const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,

[7537] Fix | Delete

// Aligned placements should not check their opposite crossAxis

[7538] Fix | Delete

// side.

[7539] Fix | Delete

getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));

[7540] Fix | Delete

const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];

[7541] Fix | Delete

if (resetPlacement !== placement) {

[7542] Fix | Delete

return {

[7543] Fix | Delete

data: {

[7544] Fix | Delete

index: currentIndex + 1,

[7545] Fix | Delete

overflows: allOverflows

[7546] Fix | Delete

},

[7547] Fix | Delete

reset: {

[7548] Fix | Delete

placement: resetPlacement

[7549] Fix | Delete

}

[7550] Fix | Delete

};

[7551] Fix | Delete

}

[7552] Fix | Delete

return {};

[7553] Fix | Delete

}

[7554] Fix | Delete

};

[7555] Fix | Delete

};

[7556] Fix | Delete

[7557] Fix | Delete

/**

[7558] Fix | Delete

* Optimizes the visibility of the floating element by flipping the `placement`

[7559] Fix | Delete

* in order to keep it in view when the preferred placement(s) will overflow the

[7560] Fix | Delete

* clipping boundary. Alternative to `autoPlacement`.

[7561] Fix | Delete

* @see https://floating-ui.com/docs/flip

[7562] Fix | Delete

*/

[7563] Fix | Delete

const flip = function (options) {

[7564] Fix | Delete

if (options === void 0) {

[7565] Fix | Delete

options = {};

[7566] Fix | Delete

}

[7567] Fix | Delete

return {

[7568] Fix | Delete

name: 'flip',

[7569] Fix | Delete

options,

[7570] Fix | Delete

async fn(state) {

[7571] Fix | Delete

var _middlewareData$arrow, _middlewareData$flip;

[7572] Fix | Delete

const {

[7573] Fix | Delete

placement,

[7574] Fix | Delete

middlewareData,

[7575] Fix | Delete

rects,

[7576] Fix | Delete

initialPlacement,

[7577] Fix | Delete

platform,

[7578] Fix | Delete

elements

[7579] Fix | Delete

} = state;

[7580] Fix | Delete

const {

[7581] Fix | Delete

mainAxis: checkMainAxis = true,

[7582] Fix | Delete

crossAxis: checkCrossAxis = true,

[7583] Fix | Delete

fallbackPlacements: specifiedFallbackPlacements,

[7584] Fix | Delete

fallbackStrategy = 'bestFit',

[7585] Fix | Delete

fallbackAxisSideDirection = 'none',

[7586] Fix | Delete

flipAlignment = true,

[7587] Fix | Delete

...detectOverflowOptions

[7588] Fix | Delete

} = floating_ui_utils_evaluate(options, state);

[7589] Fix | Delete

[7590] Fix | Delete

// If a reset by the arrow was caused due to an alignment offset being

[7591] Fix | Delete

// added, we should skip any logic now since `flip()` has already done its

[7592] Fix | Delete

// work.

[7593] Fix | Delete

// https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643

[7594] Fix | Delete

if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {

[7595] Fix | Delete

return {};

[7596] Fix | Delete

}

[7597] Fix | Delete

const side = floating_ui_utils_getSide(placement);

[7598] Fix | Delete

const isBasePlacement = floating_ui_utils_getSide(initialPlacement) === initialPlacement;

[7599] Fix | Delete

const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));

[7600] Fix | Delete

const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));

[7601] Fix | Delete

if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {

[7602] Fix | Delete

fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));

[7603] Fix | Delete

}

[7604] Fix | Delete

const placements = [initialPlacement, ...fallbackPlacements];

[7605] Fix | Delete

const overflow = await detectOverflow(state, detectOverflowOptions);

[7606] Fix | Delete

const overflows = [];

[7607] Fix | Delete

let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];

[7608] Fix | Delete

if (checkMainAxis) {

[7609] Fix | Delete

overflows.push(overflow[side]);

[7610] Fix | Delete

}

[7611] Fix | Delete

if (checkCrossAxis) {

[7612] Fix | Delete

const sides = floating_ui_utils_getAlignmentSides(placement, rects, rtl);

[7613] Fix | Delete

overflows.push(overflow[sides[0]], overflow[sides[1]]);

[7614] Fix | Delete

}

[7615] Fix | Delete

overflowsData = [...overflowsData, {

[7616] Fix | Delete

placement,

[7617] Fix | Delete

overflows

[7618] Fix | Delete

}];

[7619] Fix | Delete

[7620] Fix | Delete

// One or more sides is overflowing.

[7621] Fix | Delete

if (!overflows.every(side => side <= 0)) {

[7622] Fix | Delete

var _middlewareData$flip2, _overflowsData$filter;

[7623] Fix | Delete

const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;

[7624] Fix | Delete

const nextPlacement = placements[nextIndex];

[7625] Fix | Delete

if (nextPlacement) {

[7626] Fix | Delete

// Try next placement and re-run the lifecycle.

[7627] Fix | Delete

return {

[7628] Fix | Delete

data: {

[7629] Fix | Delete

index: nextIndex,

[7630] Fix | Delete

overflows: overflowsData

[7631] Fix | Delete

},

[7632] Fix | Delete

reset: {

[7633] Fix | Delete

placement: nextPlacement

[7634] Fix | Delete

}

[7635] Fix | Delete

};

[7636] Fix | Delete

}

[7637] Fix | Delete

[7638] Fix | Delete

// First, find the candidates that fit on the mainAxis side of overflow,

[7639] Fix | Delete

// then find the placement that fits the best on the main crossAxis side.

[7640] Fix | Delete

let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;

[7641] Fix | Delete

[7642] Fix | Delete

// Otherwise fallback.

[7643] Fix | Delete

if (!resetPlacement) {

[7644] Fix | Delete

switch (fallbackStrategy) {

[7645] Fix | Delete

case 'bestFit':

[7646] Fix | Delete

{

[7647] Fix | Delete

var _overflowsData$map$so;

[7648] Fix | Delete

const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];

[7649] Fix | Delete

if (placement) {

[7650] Fix | Delete

resetPlacement = placement;

[7651] Fix | Delete

}

[7652] Fix | Delete

break;

[7653] Fix | Delete

}

[7654] Fix | Delete

case 'initialPlacement':

[7655] Fix | Delete

resetPlacement = initialPlacement;

[7656] Fix | Delete

break;

[7657] Fix | Delete

}

[7658] Fix | Delete

}

[7659] Fix | Delete

if (placement !== resetPlacement) {

[7660] Fix | Delete

return {

[7661] Fix | Delete

reset: {

[7662] Fix | Delete

placement: resetPlacement

[7663] Fix | Delete

}

[7664] Fix | Delete

};

[7665] Fix | Delete

}

[7666] Fix | Delete

}

[7667] Fix | Delete

return {};

[7668] Fix | Delete

}

[7669] Fix | Delete

};

[7670] Fix | Delete

};

[7671] Fix | Delete

[7672] Fix | Delete

function getSideOffsets(overflow, rect) {

[7673] Fix | Delete

return {

[7674] Fix | Delete

top: overflow.top - rect.height,

[7675] Fix | Delete

right: overflow.right - rect.width,

[7676] Fix | Delete

bottom: overflow.bottom - rect.height,

[7677] Fix | Delete

left: overflow.left - rect.width

[7678] Fix | Delete

};

[7679] Fix | Delete

}

[7680] Fix | Delete

function isAnySideFullyClipped(overflow) {

[7681] Fix | Delete

return sides.some(side => overflow[side] >= 0);

[7682] Fix | Delete

}

[7683] Fix | Delete

/**

[7684] Fix | Delete

* Provides data to hide the floating element in applicable situations, such as

[7685] Fix | Delete

* when it is not in the same clipping context as the reference element.

[7686] Fix | Delete

* @see https://floating-ui.com/docs/hide

[7687] Fix | Delete

*/

[7688] Fix | Delete

const hide = function (options) {

[7689] Fix | Delete

if (options === void 0) {

[7690] Fix | Delete

options = {};

[7691] Fix | Delete

}

[7692] Fix | Delete

return {

[7693] Fix | Delete

name: 'hide',

[7694] Fix | Delete

options,

[7695] Fix | Delete

async fn(state) {

[7696] Fix | Delete

const {

[7697] Fix | Delete

rects

[7698] Fix | Delete

} = state;

[7699] Fix | Delete

const {

[7700] Fix | Delete

strategy = 'referenceHidden',

[7701] Fix | Delete

...detectOverflowOptions

[7702] Fix | Delete

} = evaluate(options, state);

[7703] Fix | Delete

switch (strategy) {

[7704] Fix | Delete

case 'referenceHidden':

[7705] Fix | Delete

{

[7706] Fix | Delete

const overflow = await detectOverflow(state, {

[7707] Fix | Delete

...detectOverflowOptions,

[7708] Fix | Delete

elementContext: 'reference'

[7709] Fix | Delete

});

[7710] Fix | Delete

const offsets = getSideOffsets(overflow, rects.reference);

[7711] Fix | Delete

return {

[7712] Fix | Delete

data: {

[7713] Fix | Delete

referenceHiddenOffsets: offsets,

[7714] Fix | Delete

referenceHidden: isAnySideFullyClipped(offsets)

[7715] Fix | Delete

}

[7716] Fix | Delete

};

[7717] Fix | Delete

}

[7718] Fix | Delete

case 'escaped':

[7719] Fix | Delete

{

[7720] Fix | Delete

const overflow = await detectOverflow(state, {

[7721] Fix | Delete

...detectOverflowOptions,

[7722] Fix | Delete

altBoundary: true

[7723] Fix | Delete

});

[7724] Fix | Delete

const offsets = getSideOffsets(overflow, rects.floating);

[7725] Fix | Delete

return {

[7726] Fix | Delete

data: {

[7727] Fix | Delete

escapedOffsets: offsets,

[7728] Fix | Delete

escaped: isAnySideFullyClipped(offsets)

[7729] Fix | Delete

}

[7730] Fix | Delete

};

[7731] Fix | Delete

}

[7732] Fix | Delete

default:

[7733] Fix | Delete

{

[7734] Fix | Delete

return {};

[7735] Fix | Delete

}

[7736] Fix | Delete

}

[7737] Fix | Delete

}

[7738] Fix | Delete

};

[7739] Fix | Delete

};

[7740] Fix | Delete

[7741] Fix | Delete

function getBoundingRect(rects) {

[7742] Fix | Delete

const minX = min(...rects.map(rect => rect.left));

[7743] Fix | Delete

const minY = min(...rects.map(rect => rect.top));

[7744] Fix | Delete

const maxX = max(...rects.map(rect => rect.right));

[7745] Fix | Delete

const maxY = max(...rects.map(rect => rect.bottom));

[7746] Fix | Delete

return {

[7747] Fix | Delete

x: minX,

[7748] Fix | Delete

y: minY,

[7749] Fix | Delete

width: maxX - minX,

[7750] Fix | Delete

height: maxY - minY

[7751] Fix | Delete

};

[7752] Fix | Delete

}

[7753] Fix | Delete

function getRectsByLine(rects) {

[7754] Fix | Delete

const sortedRects = rects.slice().sort((a, b) => a.y - b.y);

[7755] Fix | Delete

const groups = [];

[7756] Fix | Delete

let prevRect = null;

[7757] Fix | Delete

for (let i = 0; i < sortedRects.length; i++) {

[7758] Fix | Delete

const rect = sortedRects[i];

[7759] Fix | Delete

if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {

[7760] Fix | Delete

groups.push([rect]);

[7761] Fix | Delete

} else {

[7762] Fix | Delete

groups[groups.length - 1].push(rect);

[7763] Fix | Delete

}

[7764] Fix | Delete

prevRect = rect;

[7765] Fix | Delete

}

[7766] Fix | Delete

return groups.map(rect => rectToClientRect(getBoundingRect(rect)));

[7767] Fix | Delete

}

[7768] Fix | Delete

/**

[7769] Fix | Delete

* Provides improved positioning for inline reference elements that can span

[7770] Fix | Delete

* over multiple lines, such as hyperlinks or range selections.

[7771] Fix | Delete

* @see https://floating-ui.com/docs/inline

[7772] Fix | Delete

*/

[7773] Fix | Delete

const inline = function (options) {

[7774] Fix | Delete

if (options === void 0) {

[7775] Fix | Delete

options = {};

[7776] Fix | Delete

}

[7777] Fix | Delete

return {

[7778] Fix | Delete

name: 'inline',

[7779] Fix | Delete

options,

[7780] Fix | Delete

async fn(state) {

[7781] Fix | Delete

const {

[7782] Fix | Delete

placement,

[7783] Fix | Delete

elements,

[7784] Fix | Delete

rects,

[7785] Fix | Delete

platform,

[7786] Fix | Delete

strategy

[7787] Fix | Delete

} = state;

[7788] Fix | Delete

// A MouseEvent's client{X,Y} coords can be up to 2 pixels off a

[7789] Fix | Delete

// ClientRect's bounds, despite the event listener being triggered. A

[7790] Fix | Delete

// padding of 2 seems to handle this issue.

[7791] Fix | Delete

const {

[7792] Fix | Delete

padding = 2,

[7793] Fix | Delete

x,

[7794] Fix | Delete

y

[7795] Fix | Delete

} = evaluate(options, state);

[7796] Fix | Delete

const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);

[7797] Fix | Delete

const clientRects = getRectsByLine(nativeClientRects);

[7798] Fix | Delete

const fallback = rectToClientRect(getBoundingRect(nativeClientRects));

[7799] Fix | Delete

const paddingObject = getPaddingObject(padding);

[7800] Fix | Delete

function getBoundingClientRect() {

[7801] Fix | Delete

// There are two rects and they are disjoined.

[7802] Fix | Delete

if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {

[7803] Fix | Delete

// Find the first rect in which the point is fully inside.

[7804] Fix | Delete

return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;

[7805] Fix | Delete

}

[7806] Fix | Delete

[7807] Fix | Delete

// There are 2 or more connected rects.

[7808] Fix | Delete

if (clientRects.length >= 2) {

[7809] Fix | Delete

if (getSideAxis(placement) === 'y') {

[7810] Fix | Delete

const firstRect = clientRects[0];

[7811] Fix | Delete

const lastRect = clientRects[clientRects.length - 1];

[7812] Fix | Delete

const isTop = getSide(placement) === 'top';

[7813] Fix | Delete

const top = firstRect.top;

[7814] Fix | Delete

const bottom = lastRect.bottom;

[7815] Fix | Delete

const left = isTop ? firstRect.left : lastRect.left;

[7816] Fix | Delete

const right = isTop ? firstRect.right : lastRect.right;

[7817] Fix | Delete

const width = right - left;

[7818] Fix | Delete

const height = bottom - top;

[7819] Fix | Delete

return {

[7820] Fix | Delete

top,

[7821] Fix | Delete

bottom,

[7822] Fix | Delete

left,

[7823] Fix | Delete

right,

[7824] Fix | Delete

width,

[7825] Fix | Delete

height,

[7826] Fix | Delete

x: left,

[7827] Fix | Delete

y: top

[7828] Fix | Delete

};

[7829] Fix | Delete

}

[7830] Fix | Delete

const isLeftSide = getSide(placement) === 'left';

[7831] Fix | Delete

const maxRight = max(...clientRects.map(rect => rect.right));

[7832] Fix | Delete

const minLeft = min(...clientRects.map(rect => rect.left));

[7833] Fix | Delete

const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);

[7834] Fix | Delete

const top = measureRects[0].top;

[7835] Fix | Delete

const bottom = measureRects[measureRects.length - 1].bottom;

[7836] Fix | Delete

const left = minLeft;

[7837] Fix | Delete

const right = maxRight;

[7838] Fix | Delete

const width = right - left;

[7839] Fix | Delete

const height = bottom - top;

[7840] Fix | Delete

return {

[7841] Fix | Delete

top,

[7842] Fix | Delete

bottom,

[7843] Fix | Delete

left,

[7844] Fix | Delete

right,

[7845] Fix | Delete

width,

[7846] Fix | Delete

height,

[7847] Fix | Delete

x: left,

[7848] Fix | Delete

y: top

[7849] Fix | Delete

};

[7850] Fix | Delete

}

[7851] Fix | Delete

return fallback;

[7852] Fix | Delete

}

[7853] Fix | Delete

const resetRects = await platform.getElementRects({

[7854] Fix | Delete

reference: {

[7855] Fix | Delete

getBoundingClientRect

[7856] Fix | Delete

},

[7857] Fix | Delete

floating: elements.floating,

[7858] Fix | Delete

strategy

[7859] Fix | Delete

});

[7860] Fix | Delete

if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {

[7861] Fix | Delete

return {

[7862] Fix | Delete

reset: {

[7863] Fix | Delete

rects: resetRects

[7864] Fix | Delete

}

[7865] Fix | Delete

};

[7866] Fix | Delete

}

[7867] Fix | Delete

return {};

[7868] Fix | Delete

}

[7869] Fix | Delete

};

[7870] Fix | Delete

};

[7871] Fix | Delete

[7872] Fix | Delete

// For type backwards-compatibility, the `OffsetOptions` type was also

[7873] Fix | Delete

// Derivable.

[7874] Fix | Delete

async function convertValueToCoords(state, options) {

[7875] Fix | Delete

const {

[7876] Fix | Delete

placement,

[7877] Fix | Delete

platform,

[7878] Fix | Delete

elements

[7879] Fix | Delete

} = state;

[7880] Fix | Delete

const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));

[7881] Fix | Delete

const side = floating_ui_utils_getSide(placement);

[7882] Fix | Delete

const alignment = floating_ui_utils_getAlignment(placement);

[7883] Fix | Delete

const isVertical = floating_ui_utils_getSideAxis(placement) === 'y';

[7884] Fix | Delete

const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;

[7885] Fix | Delete

const crossAxisMulti = rtl && isVertical ? -1 : 1;

[7886] Fix | Delete

const rawValue = floating_ui_utils_evaluate(options, state);

[7887] Fix | Delete

[7888] Fix | Delete

// eslint-disable-next-line prefer-const

[7889] Fix | Delete

let {

[7890] Fix | Delete

mainAxis,

[7891] Fix | Delete

crossAxis,

[7892] Fix | Delete

alignmentAxis

[7893] Fix | Delete

} = typeof rawValue === 'number' ? {

[7894] Fix | Delete

mainAxis: rawValue,

[7895] Fix | Delete

crossAxis: 0,

[7896] Fix | Delete

alignmentAxis: null

[7897] Fix | Delete

} : {

[7898] Fix | Delete

mainAxis: 0,

[7899] Fix | Delete

crossAxis: 0,

[7900] Fix | Delete

alignmentAxis: null,

[7901] Fix | Delete

...rawValue

[7902] Fix | Delete

};

[7903] Fix | Delete

if (alignment && typeof alignmentAxis === 'number') {

[7904] Fix | Delete

crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;

[7905] Fix | Delete

}

[7906] Fix | Delete

return isVertical ? {

[7907] Fix | Delete

x: crossAxis * crossAxisMulti,

[7908] Fix | Delete

y: mainAxis * mainAxisMulti

[7909] Fix | Delete

} : {

[7910] Fix | Delete

x: mainAxis * mainAxisMulti,

[7911] Fix | Delete

y: crossAxis * crossAxisMulti

[7912] Fix | Delete

};

[7913] Fix | Delete

}

[7914] Fix | Delete

[7915] Fix | Delete

/**

[7916] Fix | Delete

* Modifies the placement by translating the floating element along the

[7917] Fix | Delete

* specified axes.

[7918] Fix | Delete

* A number (shorthand for `mainAxis` or distance), or an axes configuration

[7919] Fix | Delete

* object may be passed.

[7920] Fix | Delete

* @see https://floating-ui.com/docs/offset

[7921] Fix | Delete

*/

[7922] Fix | Delete

const offset = function (options) {

[7923] Fix | Delete

if (options === void 0) {

[7924] Fix | Delete

options = 0;

[7925] Fix | Delete

}

[7926] Fix | Delete

return {

[7927] Fix | Delete

name: 'offset',

[7928] Fix | Delete

options,

[7929] Fix | Delete

async fn(state) {

[7930] Fix | Delete

const {

[7931] Fix | Delete

x,

[7932] Fix | Delete

y

[7933] Fix | Delete

} = state;

[7934] Fix | Delete

const diffCoords = await convertValueToCoords(state, options);

[7935] Fix | Delete

return {

[7936] Fix | Delete

x: x + diffCoords.x,

[7937] Fix | Delete

y: y + diffCoords.y,

[7938] Fix | Delete

data: diffCoords

[7939] Fix | Delete

};

[7940] Fix | Delete

}

[7941] Fix | Delete

};

[7942] Fix | Delete

};

[7943] Fix | Delete

[7944] Fix | Delete

/**

[7945] Fix | Delete

* Optimizes the visibility of the floating element by shifting it in order to

[7946] Fix | Delete

* keep it in view when it will overflow the clipping boundary.

[7947] Fix | Delete

* @see https://floating-ui.com/docs/shift

[7948] Fix | Delete

*/

[7949] Fix | Delete

const shift = function (options) {

[7950] Fix | Delete

if (options === void 0) {

[7951] Fix | Delete

options = {};

[7952] Fix | Delete

}

[7953] Fix | Delete

return {

[7954] Fix | Delete

name: 'shift',

[7955] Fix | Delete

options,

[7956] Fix | Delete

async fn(state) {

[7957] Fix | Delete

const {

[7958] Fix | Delete

x,

[7959] Fix | Delete

y,

[7960] Fix | Delete

placement

[7961] Fix | Delete

} = state;

[7962] Fix | Delete

const {

[7963] Fix | Delete

mainAxis: checkMainAxis = true,

[7964] Fix | Delete

crossAxis: checkCrossAxis = false,

[7965] Fix | Delete

limiter = {

[7966] Fix | Delete

fn: _ref => {

[7967] Fix | Delete

let {

[7968] Fix | Delete

x,

[7969] Fix | Delete

y

[7970] Fix | Delete

} = _ref;

[7971] Fix | Delete

return {

[7972] Fix | Delete

x,

[7973] Fix | Delete

y

[7974] Fix | Delete

};

[7975] Fix | Delete

}

[7976] Fix | Delete

},

[7977] Fix | Delete

...detectOverflowOptions

[7978] Fix | Delete

} = floating_ui_utils_evaluate(options, state);

[7979] Fix | Delete

const coords = {

[7980] Fix | Delete

x,

[7981] Fix | Delete

y

[7982] Fix | Delete

};

[7983] Fix | Delete

const overflow = await detectOverflow(state, detectOverflowOptions);

[7984] Fix | Delete

const crossAxis = floating_ui_utils_getSideAxis(floating_ui_utils_getSide(placement));

[7985] Fix | Delete

const mainAxis = getOppositeAxis(crossAxis);

[7986] Fix | Delete

let mainAxisCoord = coords[mainAxis];

[7987] Fix | Delete

let crossAxisCoord = coords[crossAxis];

[7988] Fix | Delete

if (checkMainAxis) {

[7989] Fix | Delete

const minSide = mainAxis === 'y' ? 'top' : 'left';

[7990] Fix | Delete

const maxSide = mainAxis === 'y' ? 'bottom' : 'right';

[7991] Fix | Delete

const min = mainAxisCoord + overflow[minSide];

[7992] Fix | Delete

const max = mainAxisCoord - overflow[maxSide];

[7993] Fix | Delete

mainAxisCoord = clamp(min, mainAxisCoord, max);

[7994] Fix | Delete

}

[7995] Fix | Delete

if (checkCrossAxis) {

[7996] Fix | Delete

const minSide = crossAxis === 'y' ? 'top' : 'left';

[7997] Fix | Delete

const maxSide = crossAxis === 'y' ? 'bottom' : 'right';

[7998] Fix | Delete

const min = crossAxisCoord + overflow[minSide];

[7999] Fix | Delete