cbvirtua 1.0.6 → 1.0.8

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

@@ -1,22 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

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

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

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

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

@@ -1,4 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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
-    );
-}

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

@@ -1,40 +0,0 @@
-import { getBoundingClientRect } from './getBoundingClientRect';
-import { getDocumentElement } from './getDocumentElement';
-import { getNodeName } from './getNodeName';
-import { getNodeScroll } from './getNodeScroll';
-import getWindowScrollBarX from './getWindowScrollBarX';
-import { isHTMLElement, isScrollParent } from './is';
-import { round } from './math';
-function isScaled(element) {
-    const rect = getBoundingClientRect(element);
-    return (round(rect.width) !== element.offsetWidth ||
-        round(rect.height) !== element.offsetHeight);
-}
-export function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-    const isOffsetParentAnElement = isHTMLElement(offsetParent);
-    const documentElement = getDocumentElement(offsetParent);
-    const rect = getBoundingClientRect(element, isOffsetParentAnElement && isScaled(offsetParent));
-    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;
-        }
-        else if (documentElement) {
-            offsets.x = getWindowScrollBarX(documentElement);
-        }
-    }
-    return {
-        x: rect.left + scroll.scrollLeft - offsets.x,
-        y: rect.top + scroll.scrollTop - offsets.y,
-        width: rect.width,
-        height: rect.height,
-    };
-}

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

@@ -1,13 +0,0 @@
-import { getParentNode } from './getParentNode';
-import { getNodeName } from './getNodeName';
-import { isScrollParent, isHTMLElement } from './is';
-export function getScrollParent(node) {
-    if (['html', 'body', '#document'].includes(getNodeName(node))) {
-        // @ts-ignore assume body is always available
-        return node.ownerDocument.body;
-    }
-    if (isHTMLElement(node) && isScrollParent(node)) {
-        return node;
-    }
-    return getScrollParent(getParentNode(node));
-}

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

@@ -1,18 +0,0 @@
-import { getScrollParent } from './getScrollParent';
-import { getParentNode } from './getParentNode';
-import { getWindow } from './window';
-import { isScrollParent } from './is';
-export function getScrollParents(node, list = []) {
-    var _a;
-    const scrollParent = getScrollParent(node);
-    const isBody = scrollParent === ((_a = node.ownerDocument) === null || _a === void 0 ? void 0 : _a.body);
-    const win = getWindow(scrollParent);
-    const target = isBody
-        ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : [])
-        : scrollParent;
-    const updatedList = list.concat(target);
-    return isBody
-        ? updatedList
-        : // @ts-ignore: isBody tells us target will be an HTMLElement here
-            updatedList.concat(getScrollParents(getParentNode(target)));
-}

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

@@ -1,25 +0,0 @@
-import { getWindow } from './window';
-import { getDocumentElement } from './getDocumentElement';
-export function getViewportRect(element) {
-    const win = getWindow(element);
-    const html = getDocumentElement(element);
-    const visualViewport = win.visualViewport;
-    let width = html.clientWidth;
-    let height = html.clientHeight;
-    let x = 0;
-    let y = 0;
-    if (visualViewport) {
-        width = visualViewport.width;
-        height = visualViewport.height;
-        // Uses Layout Viewport (like Chrome; Safari does not currently)
-        // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
-        // errors due to floating point numbers, so we need to check precision.
-        // Safari returns a number <= 0, usually < -1 when pinch-zoomed
-        if (Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
-            0.01) {
-            x = visualViewport.offsetLeft;
-            y = visualViewport.offsetTop;
-        }
-    }
-    return { width, height, x, y };
-}

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

@@ -1,9 +0,0 @@
-import { getBoundingClientRect } from './getBoundingClientRect';
-import { getDocumentElement } from './getDocumentElement';
-import { getNodeScroll } from './getNodeScroll';
-export default function getWindowScrollBarX(element) {
-    // If <html> has a CSS width greater than the viewport, then this will be
-    // incorrect for RTL.
-    return (getBoundingClientRect(getDocumentElement(element)).left +
-        getNodeScroll(element).scrollLeft);
-}

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

@@ -1,38 +0,0 @@
-import { getComputedStyle } from './getComputedStyle';
-import { getNodeName } from './getNodeName';
-import { getWindow } from './window';
-export function isHTMLElement(value) {
-    return value instanceof getWindow(value).HTMLElement;
-}
-export function isElement(value) {
-    return value instanceof getWindow(value).Element;
-}
-export function isNode(value) {
-    return value instanceof getWindow(value).Node;
-}
-export function isShadowRoot(node) {
-    const OwnElement = getWindow(node).ShadowRoot;
-    return node instanceof OwnElement || node instanceof ShadowRoot;
-}
-export function isScrollParent(element) {
-    // Firefox wants us to check `-x` and `-y` variations as well
-    const { overflow, overflowX, overflowY } = getComputedStyle(element);
-    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
-}
-export function isTableElement(element) {
-    return ['table', 'td', 'th'].includes(getNodeName(element));
-}
-export function isContainingBlock(element) {
-    // TODO: Try and use feature detection here instead
-    const isFirefox = navigator.userAgent.toLowerCase().includes('firefox');
-    const css = getComputedStyle(element);
-    // This is non-exhaustive but covers the most common CSS properties that
-    // create a containing block.
-    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-    return (css.transform !== 'none' ||
-        css.perspective !== 'none' ||
-        css.contain === 'paint' ||
-        ['transform', 'perspective'].includes(css.willChange) ||
-        (isFirefox && css.willChange === 'filter') ||
-        (isFirefox && (css.filter ? css.filter !== 'none' : false)));
-}

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

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

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

@@ -1,13 +0,0 @@
-export function isWindow(value) {
-    return (value === null || value === void 0 ? void 0 : value.toString()) === '[object Window]';
-}
-export function getWindow(node) {
-    if (node == null) {
-        return window;
-    }
-    if (!isWindow(node)) {
-        const ownerDocument = node.ownerDocument;
-        return ownerDocument ? ownerDocument.defaultView || window : window;
-    }
-    return node;
-}

package/v2/index.js

@@ -1,75 +0,0 @@
-import { assign } from './util/assign-deep';
-import { config } from './config';
-import 'vue-resize/dist/vue-resize.css';
-// Components
-import PrivateDropdown from './components/Dropdown.vue';
-import PrivateMenu from './components/Menu.vue';
-import PrivatePopper from './components/Popper';
-import PrivatePopperContent from './components/PopperContent.vue';
-import PrivatePopperMethods from './components/PopperMethods';
-import PrivatePopperWrapper from './components/PopperWrapper.vue';
-import PrivateThemeClass from './components/ThemeClass';
-import PrivateTooltip from './components/Tooltip.vue';
-import PrivateTooltipDirective from './components/TooltipDirective.vue';
-// Directives
-import PrivateVTooltip from './directives/v-tooltip';
-import PrivateVClosePopper from './directives/v-close-popper';
-/* Exports */
-export const options = config;
-// Directive
-export const VTooltip = PrivateVTooltip;
-export { createTooltip, destroyTooltip } from './directives/v-tooltip';
-export const VClosePopper = PrivateVClosePopper;
-console.log(PrivateVClosePopper)
-// Components
-export const Dropdown = PrivateDropdown;
-export const Menu = PrivateMenu;
-export const Popper = PrivatePopper;
-export const PopperContent = PrivatePopperContent;
-export const PopperMethods = PrivatePopperMethods;
-export const PopperWrapper = PrivatePopperWrapper;
-export const ThemeClass = PrivateThemeClass;
-export const Tooltip = PrivateTooltip;
-export const TooltipDirective = PrivateTooltipDirective;
-// Utils
-export { hideAllPoppers } from './components/Popper';
-export * from './util/events';
-export { placements } from './util/popper';
-/* Vue plugin */
-export function install(app, options = {}) {
-    if (app.$_vTooltipInstalled)
-        return;
-    app.$_vTooltipInstalled = true;
-    assign(config, options);
-    // Directive
-    app.directive('tooltip', PrivateVTooltip);
-    app.directive('close-popper', PrivateVClosePopper);
-    // Components
-    // eslint-disable-next-line vue/component-definition-name-casing
-    app.component('v-tooltip', PrivateTooltip);
-    app.component('VTooltip', PrivateTooltip);
-    // eslint-disable-next-line vue/component-definition-name-casing
-    app.component('v-dropdown', PrivateDropdown);
-    app.component('VDropdown', PrivateDropdown);
-    // eslint-disable-next-line vue/component-definition-name-casing
-    app.component('v-menu', PrivateMenu);
-    app.component('VMenu', PrivateMenu);
-}
-const plugin = {
-    // eslint-disable-next-line no-undef
-    //version: VERSION,
-    install,
-    options: config,
-};
-// Auto-install
-let GlobalVue = null;
-if (typeof window !== 'undefined') {
-    GlobalVue = window.Vue;
-}
-else if (typeof global !== 'undefined') {
-    GlobalVue = global.Vue;
-}
-if (GlobalVue) {
-    GlobalVue.use(plugin);
-}
-export default plugin;

package/v2/util/assign-deep.js

@@ -1,12 +0,0 @@
-export function assign(to, from) {
-    for (const key in from) {
-        if (Object.prototype.hasOwnProperty.call(from, key)) {
-            if (typeof from[key] === 'object' && to[key]) {
-                assign(to[key], from[key]);
-            }
-            else {
-                to[key] = from[key];
-            }
-        }
-    }
-}

package/v2/util/env.js

@@ -1,18 +0,0 @@
-export let supportsPassive = false;
-if (typeof window !== 'undefined') {
-    supportsPassive = false;
-    try {
-        const opts = Object.defineProperty({}, 'passive', {
-            get() {
-                supportsPassive = true;
-            },
-        });
-        window.addEventListener('test', null, opts);
-    }
-    catch (e) { }
-}
-export let isIOS = false;
-if (typeof window !== 'undefined' && typeof navigator !== 'undefined') {
-    // @ts-expect-error MSStream is missing in window type
-    isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
-}

package/v2/util/events.js

@@ -1,12 +0,0 @@
-export const SHOW_EVENT_MAP = {
-    hover: 'mouseenter',
-    focus: 'focus',
-    click: 'click',
-    touch: 'touchstart',
-};
-export const HIDE_EVENT_MAP = {
-    hover: 'mouseleave',
-    focus: 'blur',
-    click: 'click',
-    touch: 'touchend',
-};

package/v2/util/frame.js

@@ -1,5 +0,0 @@
-export function nextFrame() {
-    return new Promise(resolve => requestAnimationFrame(() => {
-        requestAnimationFrame(resolve);
-    }));
-}

package/v2/util/lang.js

@@ -1,6 +0,0 @@
-export function removeFromArray(array, item) {
-    const index = array.indexOf(item);
-    if (index !== -1) {
-        array.splice(index, 1);
-    }
-}

package/v2/util/popper.js

@@ -1,5 +0,0 @@
-export const placements = ['auto', 'top', 'bottom', 'left', 'right'].reduce((acc, base) => acc.concat([
-    base,
-    `${base}-start`,
-    `${base}-end`,
-]), []);

package/vue/ListItem.js

@@ -1,44 +0,0 @@
-import { jsx as _jsx } from "vue/jsx-runtime";
-/** @jsxImportSource vue */
-import { ref, defineComponent, watch } from "vue";
-import { isRTLDocument } from "../core/environment";
-/**
- * @internal
- */
-export const ListItem = /*#__PURE__*/ defineComponent({
-    props: {
-        _children: { type: Object, required: true },
-        _resizer: { type: Object, required: true },
-        _index: { type: Number, required: true },
-        _offset: { type: Number, required: true },
-        _hide: { type: Boolean },
-        _isHorizontal: { type: Boolean },
-        _element: { type: String, required: true },
-    },
-    setup(props) {
-        const elementRef = ref();
-        // The index may be changed if elements are inserted to or removed from the start of props.children
-        watch(() => elementRef.value && props._index, (_, __, onCleanup) => {
-            const cleanupObserver = props._resizer(elementRef.value, props._index);
-            onCleanup(cleanupObserver);
-        }, {
-            flush: "post",
-        });
-        return () => {
-            const { _children: children, _offset: offset, _hide: hide, _element: Element, _isHorizontal: isHorizontal, } = props;
-            const style = {
-                margin: 0,
-                padding: 0,
-                position: "absolute",
-                [isHorizontal ? "height" : "width"]: "100%",
-                [isHorizontal ? "top" : "left"]: "0px",
-                [isHorizontal ? (isRTLDocument() ? "right" : "left") : "top"]: offset + "px",
-                visibility: hide ? "hidden" : "visible",
-            };
-            if (isHorizontal) {
-                style.display = "flex";
-            }
-            return (_jsx(Element, { ref: elementRef, style: style, children: children }));
-        };
-    },
-});