cbvirtua 1.0.5 → 1.0.6

package/v2/floating-ui/core/middleware/offset.js

@@ -0,0 +1,26 @@
+import { getBasePlacement } from '../utils/getBasePlacement';
+import { getMainAxisFromPlacement } from '../utils/getMainAxisFromPlacement';
+export function convertValueToCoords({ placement, rects, value, }) {
+    const basePlacement = getBasePlacement(placement);
+    const multiplier = ['left', 'top'].includes(basePlacement) ? -1 : 1;
+    const rawValue = typeof value === 'function' ? value({ ...rects, placement }) : value;
+    const { mainAxis, crossAxis } = typeof rawValue === 'number'
+        ? { mainAxis: rawValue, crossAxis: 0 }
+        : { mainAxis: 0, crossAxis: 0, ...rawValue };
+    return getMainAxisFromPlacement(basePlacement) === 'x'
+        ? { x: crossAxis, y: mainAxis * multiplier }
+        : { x: mainAxis * multiplier, y: crossAxis };
+}
+export const offset = (value = 0) => ({
+    name: 'offset',
+    options: value,
+    fn(middlewareArguments) {
+        const { x, y, placement, rects } = middlewareArguments;
+        const diffCoords = convertValueToCoords({ placement, rects, value });
+        return {
+            x: x + diffCoords.x,
+            y: y + diffCoords.y,
+            data: diffCoords,
+        };
+    },
+});

package/v2/floating-ui/core/middleware/shift.js

@@ -0,0 +1,99 @@
+import { getBasePlacement } from '../utils/getBasePlacement';
+import { getMainAxisFromPlacement } from '../utils/getMainAxisFromPlacement';
+import { getCrossAxis } from '../utils/getCrossAxis';
+import { within } from '../utils/within';
+import { detectOverflow, } from '../detectOverflow';
+export const shift = (options = {}) => ({
+    name: 'shift',
+    options,
+    async fn(middlewareArguments) {
+        const { x, y, placement } = middlewareArguments;
+        const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: ({ x, y }) => ({ x, y }) }, ...detectOverflowOptions } = options;
+        const coords = { x, y };
+        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+        const mainAxis = getMainAxisFromPlacement(getBasePlacement(placement));
+        const crossAxis = getCrossAxis(mainAxis);
+        let mainAxisCoord = coords[mainAxis];
+        let crossAxisCoord = coords[crossAxis];
+        if (checkMainAxis) {
+            const minSide = mainAxis === 'y' ? 'top' : 'left';
+            const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
+            const min = mainAxisCoord + overflow[minSide];
+            const max = mainAxisCoord - overflow[maxSide];
+            mainAxisCoord = within(min, mainAxisCoord, max);
+        }
+        if (checkCrossAxis) {
+            const minSide = crossAxis === 'y' ? 'top' : 'left';
+            const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
+            const min = crossAxisCoord + overflow[minSide];
+            const max = crossAxisCoord - overflow[maxSide];
+            crossAxisCoord = within(min, crossAxisCoord, max);
+        }
+        const limitedCoords = limiter.fn({
+            ...middlewareArguments,
+            [mainAxis]: mainAxisCoord,
+            [crossAxis]: crossAxisCoord,
+        });
+        return {
+            ...limitedCoords,
+            data: {
+                x: limitedCoords.x - x,
+                y: limitedCoords.y - y,
+            },
+        };
+    },
+});
+export const limitShift = (options = {}) => ({
+    options,
+    fn(middlewareArguments) {
+        var _a, _b, _c, _d;
+        const { x, y, placement, rects, middlewareData } = middlewareArguments;
+        const { offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, } = options;
+        const coords = { x, y };
+        const mainAxis = getMainAxisFromPlacement(placement);
+        const crossAxis = getCrossAxis(mainAxis);
+        let mainAxisCoord = coords[mainAxis];
+        let crossAxisCoord = coords[crossAxis];
+        const rawOffset = typeof offset === 'function' ? offset({ ...rects, placement }) : offset;
+        const computedOffset = typeof rawOffset === 'number'
+            ? { mainAxis: rawOffset, crossAxis: 0 }
+            : { mainAxis: 0, crossAxis: 0, ...rawOffset };
+        if (checkMainAxis) {
+            const len = mainAxis === 'y' ? 'height' : 'width';
+            const limitMin = rects.reference[mainAxis] -
+                rects.floating[len] +
+                computedOffset.mainAxis;
+            const limitMax = rects.reference[mainAxis] +
+                rects.reference[len] -
+                computedOffset.mainAxis;
+            if (mainAxisCoord < limitMin) {
+                mainAxisCoord = limitMin;
+            }
+            else if (mainAxisCoord > limitMax) {
+                mainAxisCoord = limitMax;
+            }
+        }
+        if (checkCrossAxis) {
+            const len = mainAxis === 'y' ? 'width' : 'height';
+            const isOriginSide = ['top', 'left'].includes(getBasePlacement(placement));
+            const limitMin = rects.reference[crossAxis] -
+                rects.floating[len] -
+                ((_b = (_a = middlewareData.offset) === null || _a === void 0 ? void 0 : _a[mainAxis]) !== null && _b !== void 0 ? _b : 0) +
+                (isOriginSide ? 0 : computedOffset.crossAxis);
+            const limitMax = rects.reference[crossAxis] +
+                rects.reference[len] +
+                ((_d = (_c = middlewareData.offset) === null || _c === void 0 ? void 0 : _c[mainAxis]) !== null && _d !== void 0 ? _d : 0) -
+                (isOriginSide ? computedOffset.crossAxis : 0);
+            if (crossAxisCoord < limitMin) {
+                crossAxisCoord = limitMin;
+            }
+            else if (crossAxisCoord > limitMax) {
+                crossAxisCoord = limitMax;
+            }
+        }
+        return {
+            [mainAxis]: mainAxisCoord,
+            [crossAxis]: crossAxisCoord,
+        };
+    },
+});

package/v2/floating-ui/core/middleware/size.js

@@ -0,0 +1,58 @@
+import { detectOverflow, } from '../detectOverflow';
+import { getBasePlacement } from '../utils/getBasePlacement';
+import { getAlignment } from '../utils/getAlignment';
+import { max } from '../utils/math';
+export const size = (options = {}) => ({
+    name: 'size',
+    options,
+    async fn(middlewareArguments) {
+        var _a;
+        const { placement, rects, middlewareData } = middlewareArguments;
+        const { apply, ...detectOverflowOptions } = options;
+        if ((_a = middlewareData.size) === null || _a === void 0 ? void 0 : _a.skip) {
+            return {};
+        }
+        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+        const basePlacement = getBasePlacement(placement);
+        const isEnd = getAlignment(placement) === 'end';
+        let heightSide;
+        let widthSide;
+        if (basePlacement === 'top' || basePlacement === 'bottom') {
+            heightSide = basePlacement;
+            widthSide = isEnd ? 'left' : 'right';
+        }
+        else {
+            widthSide = basePlacement;
+            heightSide = isEnd ? 'top' : 'bottom';
+        }
+        const xMin = max(overflow.left, 0);
+        const xMax = max(overflow.right, 0);
+        const yMin = max(overflow.top, 0);
+        const yMax = max(overflow.bottom, 0);
+        const dimensions = {
+            height: rects.floating.height -
+                (['left', 'right'].includes(placement)
+                    ? 2 *
+                        (yMin !== 0 || yMax !== 0
+                            ? yMin + yMax
+                            : max(overflow.top, overflow.bottom))
+                    : overflow[heightSide]),
+            width: rects.floating.width -
+                (['top', 'bottom'].includes(placement)
+                    ? 2 *
+                        (xMin !== 0 || xMax !== 0
+                            ? xMin + xMax
+                            : max(overflow.left, overflow.right))
+                    : overflow[widthSide]),
+        };
+        apply === null || apply === void 0 ? void 0 : apply({ ...dimensions, ...rects });
+        return {
+            data: {
+                skip: true,
+            },
+            reset: {
+                rects: true,
+            },
+        };
+    },
+});

package/v2/floating-ui/core/types.js

@@ -0,0 +1,11 @@
+export { computePosition } from './computePosition';
+export { rectToClientRect } from './utils/rectToClientRect';
+export { detectOverflow } from './detectOverflow';
+export { arrow } from './middleware/arrow';
+export { autoPlacement } from './middleware/autoPlacement';
+export { flip } from './middleware/flip';
+export { hide } from './middleware/hide';
+export { offset } from './middleware/offset';
+export { shift, limitShift } from './middleware/shift';
+export { size } from './middleware/size';
+export { inline } from './middleware/inline';

package/v2/floating-ui/core/utils/expandPaddingObject.js

@@ -0,0 +1,3 @@
+export function expandPaddingObject(padding) {
+    return { top: 0, right: 0, bottom: 0, left: 0, ...padding };
+}

package/v2/floating-ui/core/utils/getAlignment.js

@@ -0,0 +1,3 @@
+export function getAlignment(placement) {
+    return placement.split('-')[1];
+}

package/v2/floating-ui/core/utils/getAlignmentSides.js

@@ -0,0 +1,23 @@
+import { getLengthFromAxis } from './getLengthFromAxis';
+import { getMainAxisFromPlacement } from './getMainAxisFromPlacement';
+import { getOppositePlacement } from './getOppositePlacement';
+import { getAlignment } from './getAlignment';
+export function getAlignmentSides(placement, rects) {
+    const isStart = getAlignment(placement) === 'start';
+    const mainAxis = getMainAxisFromPlacement(placement);
+    const length = getLengthFromAxis(mainAxis);
+    let mainAlignmentSide = mainAxis === 'x'
+        ? isStart
+            ? 'right'
+            : 'left'
+        : isStart
+            ? 'bottom'
+            : 'top';
+    if (rects.reference[length] > rects.floating[length]) {
+        mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+    }
+    return {
+        main: mainAlignmentSide,
+        cross: getOppositePlacement(mainAlignmentSide),
+    };
+}

package/v2/floating-ui/core/utils/getBasePlacement.js

@@ -0,0 +1,3 @@
+export function getBasePlacement(placement) {
+    return placement.split('-')[0];
+}

package/v2/floating-ui/core/utils/getCrossAxis.js

@@ -0,0 +1,3 @@
+export function getCrossAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
+}

package/v2/floating-ui/core/utils/getExpandedPlacements.js

@@ -0,0 +1,10 @@
+import { getOppositePlacement } from './getOppositePlacement';
+import { getOppositeAlignmentPlacement } from './getOppositeAlignmentPlacement';
+export function getExpandedPlacements(placement) {
+    const oppositePlacement = getOppositePlacement(placement);
+    return [
+        getOppositeAlignmentPlacement(placement),
+        oppositePlacement,
+        getOppositeAlignmentPlacement(oppositePlacement),
+    ];
+}

package/v2/floating-ui/core/utils/getLengthFromAxis.js

@@ -0,0 +1,3 @@
+export function getLengthFromAxis(axis) {
+    return axis === 'y' ? 'height' : 'width';
+}

package/v2/floating-ui/core/utils/getMainAxisFromPlacement.js

@@ -0,0 +1,4 @@
+import { getBasePlacement } from './getBasePlacement';
+export function getMainAxisFromPlacement(placement) {
+    return ['top', 'bottom'].includes(getBasePlacement(placement)) ? 'x' : 'y';
+}

package/v2/floating-ui/core/utils/getOppositeAlignmentPlacement.js

@@ -0,0 +1,4 @@
+const hash = { start: 'end', end: 'start' };
+export function getOppositeAlignmentPlacement(placement) {
+    return placement.replace(/start|end/g, (matched) => hash[matched]);
+}

package/v2/floating-ui/core/utils/getOppositePlacement.js

@@ -0,0 +1,4 @@
+const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
+export function getOppositePlacement(placement) {
+    return placement.replace(/left|right|bottom|top/g, (matched) => hash[matched]);
+}

package/v2/floating-ui/core/utils/getPaddingObject.js

@@ -0,0 +1,6 @@
+import { expandPaddingObject } from './expandPaddingObject';
+export function getSideObjectFromPadding(padding) {
+    return typeof padding !== 'number'
+        ? expandPaddingObject(padding)
+        : { top: padding, right: padding, bottom: padding, left: padding };
+}

package/v2/floating-ui/core/utils/math.js

@@ -0,0 +1,2 @@
+export const min = Math.min;
+export const max = Math.max;

package/v2/floating-ui/core/utils/rectToClientRect.js

@@ -0,0 +1,9 @@
+export function rectToClientRect(rect) {
+    return {
+        ...rect,
+        top: rect.y,
+        left: rect.x,
+        right: rect.x + rect.width,
+        bottom: rect.y + rect.height,
+    };
+}

package/v2/floating-ui/core/utils/within.js

@@ -0,0 +1,4 @@
+import { max as mathMax, min as mathMin } from './math';
+export function within(min, value, max) {
+    return mathMax(min, mathMin(value, max));
+}

package/v2/floating-ui/dom/index.js

@@ -0,0 +1,5 @@
+import { computePosition as computePositionCore, } from '../core/index';
+import { platform } from './platform';
+export const computePosition = (reference, floating, options) => computePositionCore(reference, floating, { platform, ...options });
+export { arrow, autoPlacement, flip, hide, offset, shift, limitShift, size, inline, detectOverflow, } from '../core/index';
+export { getScrollParents } from './utils/getScrollParents';

package/v2/floating-ui/dom/platform.js

@@ -0,0 +1,20 @@
+import { getRectRelativeToOffsetParent } from './utils/getRectRelativeToOffsetParent';
+import { getOffsetParent } from './utils/getOffsetParent';
+import { getDimensions } from './utils/getDimensions';
+import { convertOffsetParentRelativeRectToViewportRelativeRect } from './utils/convertOffsetParentRelativeRectToViewportRelativeRect';
+import { isElement } from './utils/is';
+import { getDocumentElement } from './utils/getDocumentElement';
+import { getClippingClientRect } from './utils/getClippingClientRect';
+export const platform = {
+    getElementRects: ({ reference, floating, strategy }) => ({
+        reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
+        floating: { ...getDimensions(floating), x: 0, y: 0 },
+    }),
+    convertOffsetParentRelativeRectToViewportRelativeRect: (args) => convertOffsetParentRelativeRectToViewportRelativeRect(args),
+    getOffsetParent: ({ element }) => getOffsetParent(element),
+    isElement: (value) => isElement(value),
+    getDocumentElement: ({ element }) => getDocumentElement(element),
+    getClippingClientRect: (args) => getClippingClientRect(args),
+    getDimensions: ({ element }) => getDimensions(element),
+    getClientRects: ({ element }) => element.getClientRects(),
+};

package/v2/floating-ui/dom/utils/contains.js

@@ -0,0 +1,22 @@
+import { isShadowRoot } from './is';
+export function contains(parent, child) {
+    var _a;
+    const rootNode = (_a = child.getRootNode) === null || _a === void 0 ? void 0 : _a.call(child);
+    // First, attempt with faster native method
+    if (parent.contains(child)) {
+        return true;
+    }
+    // then fallback to custom implementation with Shadow DOM support
+    else if (rootNode && isShadowRoot(rootNode)) {
+        let next = child;
+        do {
+            // use `===` replace node.isSameNode()
+            if (next && parent === next) {
+                return true;
+            }
+            // @ts-ignore: need a better way to handle this...
+            next = next.parentNode || next.host;
+        } while (next);
+    }
+    return false;
+}

package/v2/floating-ui/dom/utils/convertOffsetParentRelativeRectToViewportRelativeRect.js

@@ -0,0 +1,35 @@
+import { getBoundingClientRect } from './getBoundingClientRect';
+import { getNodeScroll } from './getNodeScroll';
+import { getNodeName } from './getNodeName';
+import { getDocumentElement } from './getDocumentElement';
+import { isHTMLElement, isScrollParent } from './is';
+export function convertOffsetParentRelativeRectToViewportRelativeRect({ rect, offsetParent, strategy, }) {
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+    if (offsetParent === documentElement) {
+        return rect;
+    }
+    let scroll = { scrollLeft: 0, scrollTop: 0 };
+    const offsets = { x: 0, y: 0 };
+    if (isOffsetParentAnElement ||
+        (!isOffsetParentAnElement && strategy !== 'fixed')) {
+        if (getNodeName(offsetParent) !== 'body' ||
+            isScrollParent(documentElement)) {
+            scroll = getNodeScroll(offsetParent);
+        }
+        if (isHTMLElement(offsetParent)) {
+            const offsetRect = getBoundingClientRect(offsetParent, true);
+            offsets.x = offsetRect.x + offsetParent.clientLeft;
+            offsets.y = offsetRect.y + offsetParent.clientTop;
+        }
+        // This doesn't appear to be need to be negated.
+        // else if (documentElement) {
+        //   offsets.x = getWindowScrollBarX(documentElement);
+        // }
+    }
+    return {
+        ...rect,
+        x: rect.x - scroll.scrollLeft + offsets.x,
+        y: rect.y - scroll.scrollTop + offsets.y,
+    };
+}

package/v2/floating-ui/dom/utils/getBoundingClientRect.js

@@ -0,0 +1,27 @@
+import { isHTMLElement } from './is';
+import { round } from './math';
+export function getBoundingClientRect(element, includeScale = false) {
+    const clientRect = element.getBoundingClientRect();
+    let scaleX = 1;
+    let scaleY = 1;
+    if (includeScale && isHTMLElement(element)) {
+        scaleX =
+            element.offsetWidth > 0
+                ? round(clientRect.width) / element.offsetWidth || 1
+                : 1;
+        scaleY =
+            element.offsetHeight > 0
+                ? round(clientRect.height) / element.offsetHeight || 1
+                : 1;
+    }
+    return {
+        width: clientRect.width / scaleX,
+        height: clientRect.height / scaleY,
+        top: clientRect.top / scaleY,
+        right: clientRect.right / scaleX,
+        bottom: clientRect.bottom / scaleY,
+        left: clientRect.left / scaleX,
+        x: clientRect.left / scaleX,
+        y: clientRect.top / scaleY,
+    };
+}

package/v2/floating-ui/dom/utils/getClippingClientRect.js

@@ -0,0 +1,76 @@
+import { rectToClientRect, } from '../../core/';
+import { getViewportRect } from './getViewportRect';
+import { getDocumentRect } from './getDocumentRect';
+import { getScrollParents } from './getScrollParents';
+import { getOffsetParent } from './getOffsetParent';
+import { getDocumentElement } from './getDocumentElement';
+import { getComputedStyle } from './getComputedStyle';
+import { isElement, isHTMLElement } from './is';
+import { getBoundingClientRect } from './getBoundingClientRect';
+import { getParentNode } from './getParentNode';
+import { contains } from './contains';
+import { getNodeName } from './getNodeName';
+import { max, min } from './math';
+function getInnerBoundingClientRect(element) {
+    const clientRect = getBoundingClientRect(element);
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    return {
+        top,
+        left,
+        x: left,
+        y: top,
+        right: left + element.clientWidth,
+        bottom: top + element.clientHeight,
+        width: element.clientWidth,
+        height: element.clientHeight,
+    };
+}
+function getClientRectFromClippingParent(element, clippingParent) {
+    if (clippingParent === 'viewport') {
+        return rectToClientRect(getViewportRect(element));
+    }
+    if (isElement(clippingParent)) {
+        return getInnerBoundingClientRect(clippingParent);
+    }
+    return rectToClientRect(getDocumentRect(getDocumentElement(element)));
+}
+// A "clipping parent" is an overflowable container with the characteristic of
+// clipping (or hiding) overflowing elements with a position different from
+// `initial`
+function getClippingParents(element) {
+    const clippingParents = getScrollParents(getParentNode(element));
+    const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle(element).position);
+    const clipperElement = canEscapeClipping && isHTMLElement(element)
+        ? getOffsetParent(element)
+        : element;
+    if (!isElement(clipperElement)) {
+        return [];
+    }
+    // @ts-ignore isElement check ensures we return Array<Element>
+    return clippingParents.filter((clippingParent) => isElement(clippingParent) &&
+        contains(clippingParent, clipperElement) &&
+        getNodeName(clippingParent) !== 'body');
+}
+// Gets the maximum area that the element is visible in due to any number of
+// clipping parents
+export function getClippingClientRect({ element, boundary, rootBoundary, }) {
+    const mainClippingParents = boundary === 'clippingParents'
+        ? getClippingParents(element)
+        : [].concat(boundary);
+    const clippingParents = [...mainClippingParents, rootBoundary];
+    const firstClippingParent = clippingParents[0];
+    const clippingRect = clippingParents.reduce((accRect, clippingParent) => {
+        const rect = getClientRectFromClippingParent(element, clippingParent);
+        accRect.top = max(rect.top, accRect.top);
+        accRect.right = min(rect.right, accRect.right);
+        accRect.bottom = min(rect.bottom, accRect.bottom);
+        accRect.left = max(rect.left, accRect.left);
+        return accRect;
+    }, getClientRectFromClippingParent(element, firstClippingParent));
+    clippingRect.width = clippingRect.right - clippingRect.left;
+    clippingRect.height = clippingRect.bottom - clippingRect.top;
+    clippingRect.x = clippingRect.left;
+    clippingRect.y = clippingRect.top;
+    return clippingRect;
+}

package/v2/floating-ui/dom/utils/getComputedStyle.js

@@ -0,0 +1,4 @@
+import { getWindow } from './window';
+export function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+}

package/v2/floating-ui/dom/utils/getDimensions.js

@@ -0,0 +1,6 @@
+export function getDimensions(element) {
+    return {
+        width: element.offsetWidth,
+        height: element.offsetHeight,
+    };
+}

package/v2/floating-ui/dom/utils/getDocumentElement.js

@@ -0,0 +1,4 @@
+import { isNode } from './is';
+export function getDocumentElement(node) {
+    return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+}

package/v2/floating-ui/dom/utils/getDocumentRect.js

@@ -0,0 +1,21 @@
+import { getDocumentElement } from './getDocumentElement';
+import { getComputedStyle } from './getComputedStyle';
+import getWindowScrollBarX from './getWindowScrollBarX';
+import { getNodeScroll } from './getNodeScroll';
+import { max } from './math';
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable
+export function getDocumentRect(element) {
+    var _a;
+    const html = getDocumentElement(element);
+    const scroll = getNodeScroll(element);
+    const body = (_a = element.ownerDocument) === null || _a === void 0 ? void 0 : _a.body;
+    const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -scroll.scrollTop;
+    if (getComputedStyle(body || html).direction === 'rtl') {
+        x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+    return { width, height, x, y };
+}

package/v2/floating-ui/dom/utils/getNodeName.js

@@ -0,0 +1,4 @@
+import { isWindow } from './window';
+export function getNodeName(node) {
+    return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
+}

package/v2/floating-ui/dom/utils/getNodeScroll.js

@@ -0,0 +1,13 @@
+import { isWindow } from './window';
+export function getNodeScroll(element) {
+    if (isWindow(element)) {
+        return {
+            scrollLeft: element.pageXOffset,
+            scrollTop: element.pageYOffset,
+        };
+    }
+    return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop,
+    };
+}

package/v2/floating-ui/dom/utils/getOffsetParent.js

@@ -0,0 +1,43 @@
+import { getNodeName } from './getNodeName';
+import { getParentNode } from './getParentNode';
+import { getWindow } from './window';
+import { isContainingBlock, isHTMLElement, isTableElement } from './is';
+function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) ||
+        getComputedStyle(element).position === 'fixed') {
+        return null;
+    }
+    return element.offsetParent;
+}
+function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) &&
+        !['html', 'body'].includes(getNodeName(currentNode))) {
+        if (isContainingBlock(currentNode)) {
+            return currentNode;
+        }
+        else {
+            currentNode = currentNode.parentNode;
+        }
+    }
+    return null;
+}
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+export function getOffsetParent(element) {
+    const window = getWindow(element);
+    let offsetParent = getTrueOffsetParent(element);
+    while (offsetParent &&
+        isTableElement(offsetParent) &&
+        getComputedStyle(offsetParent).position === 'static') {
+        offsetParent = getTrueOffsetParent(offsetParent);
+    }
+    if (offsetParent &&
+        (getNodeName(offsetParent) === 'html' ||
+            (getNodeName(offsetParent) === 'body' &&
+                getComputedStyle(offsetParent).position === 'static' &&
+                !isContainingBlock(offsetParent)))) {
+        return window;
+    }
+    return offsetParent || getContainingBlock(element) || window;
+}

package/v2/floating-ui/dom/utils/getParentNode.js

@@ -0,0 +1,16 @@
+import { getNodeName } from './getNodeName';
+import { getDocumentElement } from './getDocumentElement';
+import { isShadowRoot } from './is';
+export function getParentNode(node) {
+    if (getNodeName(node) === 'html') {
+        return node;
+    }
+    return (
+    // this is a quicker (but less type safe) way to save quite some bytes from the bundle
+    // @ts-ignore
+    node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+        node.parentNode || // DOM Element detected
+        (isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
+        getDocumentElement(node) // fallback
+    );
+}