@wix/site-ui 1.30.0 → 1.32.0

package/dist/9087.js

@@ -0,0 +1,256 @@
+import { jsx } from "react/jsx-runtime";
+import { EMPTY_OBJECT, useMergedRefs, EMPTY_ARRAY as empty_EMPTY_ARRAY, useRenderElement } from "./8272.js";
+import { useStableCallback } from "./7541.js";
+import { ARROW_LEFT, scrollIntoViewIfNeeded, ARROW_UP, ARROW_DOWN, COMPOSITE_KEYS, ARROW_KEYS, VERTICAL_KEYS_WITH_EXTRA_KEYS, HORIZONTAL_KEYS, VERTICAL_KEYS, MODIFIER_KEYS, ARROW_RIGHT, HORIZONTAL_KEYS_WITH_EXTRA_KEYS, isNativeInput } from "./1500.js";
+import { ACTIVE_COMPOSITE_ITEM } from "./4346.js";
+import { getTarget } from "./4549.js";
+import { isElementDisabled } from "./3140.js";
+import { isListIndexDisabled, getGridCellIndices, findNonDisabledListIndex, getGridNavigatedIndex, createGridCellMap, getMinListIndex, getGridCellIndexOfCorner, isIndexOutOfListBounds, getMaxListIndex } from "./3319.js";
+import { useDirection } from "./9863.js";
+import { CompositeRootContext } from "./8724.js";
+import { CompositeList } from "./9255.js";
+import * as __rspack_external_react from "react";
+const EMPTY_ARRAY = [];
+function useCompositeRoot(params) {
+    const { itemSizes, cols = 1, loopFocus = true, onLoop, dense = false, orientation = 'both', direction, highlightedIndex: externalHighlightedIndex, onHighlightedIndexChange: externalSetHighlightedIndex, rootRef: externalRef, enableHomeAndEndKeys = false, stopEventPropagation = false, disabledIndices, modifierKeys = EMPTY_ARRAY } = params;
+    const [internalHighlightedIndex, internalSetHighlightedIndex] = __rspack_external_react.useState(0);
+    const isGrid = cols > 1;
+    const rootRef = __rspack_external_react.useRef(null);
+    const mergedRef = useMergedRefs(rootRef, externalRef);
+    const elementsRef = __rspack_external_react.useRef([]);
+    const hasSetDefaultIndexRef = __rspack_external_react.useRef(false);
+    const highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex;
+    const onHighlightedIndexChange = useStableCallback((index, shouldScrollIntoView = false)=>{
+        (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index);
+        if (shouldScrollIntoView) {
+            const newActiveItem = elementsRef.current[index];
+            scrollIntoViewIfNeeded(rootRef.current, newActiveItem, direction, orientation);
+        }
+    });
+    const onMapChange = useStableCallback((map)=>{
+        if (0 === map.size || hasSetDefaultIndexRef.current) return;
+        hasSetDefaultIndexRef.current = true;
+        const sortedElements = Array.from(map.keys());
+        const activeItem = sortedElements.find((compositeElement)=>compositeElement?.hasAttribute(ACTIVE_COMPOSITE_ITEM)) ?? null;
+        const activeIndex = activeItem ? sortedElements.indexOf(activeItem) : -1;
+        if (-1 !== activeIndex) onHighlightedIndexChange(activeIndex);
+        scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
+    });
+    const wrappedOnLoop = useStableCallback((event, prevIndex, nextIndex)=>{
+        if (!onLoop) return nextIndex;
+        return onLoop?.(event, prevIndex, nextIndex, elementsRef);
+    });
+    const props = __rspack_external_react.useMemo(()=>({
+            'aria-orientation': 'both' === orientation ? void 0 : orientation,
+            ref: mergedRef,
+            onFocus (event) {
+                const element = rootRef.current;
+                const target = getTarget(event.nativeEvent);
+                if (!element || null == target || !isNativeInput(target)) return;
+                target.setSelectionRange(0, target.value.length ?? 0);
+            },
+            onKeyDown (event) {
+                const RELEVANT_KEYS = enableHomeAndEndKeys ? COMPOSITE_KEYS : ARROW_KEYS;
+                if (!RELEVANT_KEYS.has(event.key)) return;
+                if (isModifierKeySet(event, modifierKeys)) return;
+                const element = rootRef.current;
+                if (!element) return;
+                const isRtl = 'rtl' === direction;
+                const horizontalForwardKey = isRtl ? ARROW_LEFT : ARROW_RIGHT;
+                const forwardKey = {
+                    horizontal: horizontalForwardKey,
+                    vertical: ARROW_DOWN,
+                    both: horizontalForwardKey
+                }[orientation];
+                const horizontalBackwardKey = isRtl ? ARROW_RIGHT : ARROW_LEFT;
+                const backwardKey = {
+                    horizontal: horizontalBackwardKey,
+                    vertical: ARROW_UP,
+                    both: horizontalBackwardKey
+                }[orientation];
+                const target = getTarget(event.nativeEvent);
+                if (null != target && isNativeInput(target) && !isElementDisabled(target)) {
+                    const selectionStart = target.selectionStart;
+                    const selectionEnd = target.selectionEnd;
+                    const textContent = target.value ?? '';
+                    if (null == selectionStart || event.shiftKey || selectionStart !== selectionEnd) return;
+                    if (event.key !== backwardKey && selectionStart < textContent.length) return;
+                    if (event.key !== forwardKey && selectionStart > 0) return;
+                }
+                let nextIndex = highlightedIndex;
+                const minIndex = getMinListIndex(elementsRef, disabledIndices);
+                const maxIndex = getMaxListIndex(elementsRef, disabledIndices);
+                if (isGrid) {
+                    const sizes = itemSizes || Array.from({
+                        length: elementsRef.current.length
+                    }, ()=>({
+                            width: 1,
+                            height: 1
+                        }));
+                    const cellMap = createGridCellMap(sizes, cols, dense);
+                    const minGridIndex = cellMap.findIndex((index)=>null != index && !isListIndexDisabled(elementsRef.current, index, disabledIndices));
+                    const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex)=>null == index || isListIndexDisabled(elementsRef.current, index, disabledIndices) ? foundIndex : cellIndex, -1);
+                    nextIndex = cellMap[getGridNavigatedIndex(cellMap.map((itemIndex)=>null != itemIndex ? elementsRef.current[itemIndex] : null), {
+                        event,
+                        orientation,
+                        loopFocus,
+                        onLoop: wrappedOnLoop,
+                        cols,
+                        disabledIndices: getGridCellIndices([
+                            ...disabledIndices || elementsRef.current.map((_, index)=>isListIndexDisabled(elementsRef.current, index) ? index : void 0),
+                            void 0
+                        ], cellMap),
+                        minIndex: minGridIndex,
+                        maxIndex: maxGridIndex,
+                        prevIndex: getGridCellIndexOfCorner(highlightedIndex > maxIndex ? minIndex : highlightedIndex, sizes, cellMap, cols, event.key === ARROW_DOWN ? 'bl' : event.key === ARROW_RIGHT ? 'tr' : 'tl'),
+                        rtl: isRtl
+                    })];
+                }
+                const forwardKeys = {
+                    horizontal: [
+                        horizontalForwardKey
+                    ],
+                    vertical: [
+                        ARROW_DOWN
+                    ],
+                    both: [
+                        horizontalForwardKey,
+                        ARROW_DOWN
+                    ]
+                }[orientation];
+                const backwardKeys = {
+                    horizontal: [
+                        horizontalBackwardKey
+                    ],
+                    vertical: [
+                        ARROW_UP
+                    ],
+                    both: [
+                        horizontalBackwardKey,
+                        ARROW_UP
+                    ]
+                }[orientation];
+                const preventedKeys = isGrid ? RELEVANT_KEYS : ({
+                    horizontal: enableHomeAndEndKeys ? HORIZONTAL_KEYS_WITH_EXTRA_KEYS : HORIZONTAL_KEYS,
+                    vertical: enableHomeAndEndKeys ? VERTICAL_KEYS_WITH_EXTRA_KEYS : VERTICAL_KEYS,
+                    both: RELEVANT_KEYS
+                })[orientation];
+                if (enableHomeAndEndKeys) {
+                    if ("Home" === event.key) nextIndex = minIndex;
+                    else if ("End" === event.key) nextIndex = maxIndex;
+                }
+                if (nextIndex === highlightedIndex && (forwardKeys.includes(event.key) || backwardKeys.includes(event.key))) if (loopFocus && nextIndex === maxIndex && forwardKeys.includes(event.key)) {
+                    nextIndex = minIndex;
+                    if (onLoop) nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+                } else if (loopFocus && nextIndex === minIndex && backwardKeys.includes(event.key)) {
+                    nextIndex = maxIndex;
+                    if (onLoop) nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+                } else nextIndex = findNonDisabledListIndex(elementsRef.current, {
+                    startingIndex: nextIndex,
+                    decrement: backwardKeys.includes(event.key),
+                    disabledIndices
+                });
+                if (nextIndex !== highlightedIndex && !isIndexOutOfListBounds(elementsRef.current, nextIndex)) {
+                    if (stopEventPropagation) event.stopPropagation();
+                    if (preventedKeys.has(event.key)) event.preventDefault();
+                    onHighlightedIndexChange(nextIndex, true);
+                    queueMicrotask(()=>{
+                        elementsRef.current[nextIndex]?.focus();
+                    });
+                }
+            }
+        }), [
+        cols,
+        dense,
+        direction,
+        disabledIndices,
+        elementsRef,
+        enableHomeAndEndKeys,
+        highlightedIndex,
+        isGrid,
+        itemSizes,
+        loopFocus,
+        onLoop,
+        wrappedOnLoop,
+        mergedRef,
+        modifierKeys,
+        onHighlightedIndexChange,
+        orientation,
+        stopEventPropagation
+    ]);
+    return __rspack_external_react.useMemo(()=>({
+            props,
+            highlightedIndex,
+            onHighlightedIndexChange,
+            elementsRef,
+            disabledIndices,
+            onMapChange,
+            relayKeyboardEvent: props.onKeyDown
+        }), [
+        props,
+        highlightedIndex,
+        onHighlightedIndexChange,
+        elementsRef,
+        disabledIndices,
+        onMapChange
+    ]);
+}
+function isModifierKeySet(event, ignoredModifierKeys) {
+    for (const key of MODIFIER_KEYS.values())if (!ignoredModifierKeys.includes(key)) {
+        if (event.getModifierState(key)) return true;
+    }
+    return false;
+}
+function CompositeRoot(componentProps) {
+    const { render, className, style, refs = empty_EMPTY_ARRAY, props = empty_EMPTY_ARRAY, state = EMPTY_OBJECT, stateAttributesMapping, highlightedIndex: highlightedIndexProp, onHighlightedIndexChange: onHighlightedIndexChangeProp, orientation, dense, itemSizes, loopFocus, onLoop, cols, enableHomeAndEndKeys, onMapChange: onMapChangeProp, stopEventPropagation = true, rootRef, disabledIndices, modifierKeys, highlightItemOnHover = false, tag = 'div', ...elementProps } = componentProps;
+    const direction = useDirection();
+    const { props: defaultProps, highlightedIndex, onHighlightedIndexChange, elementsRef, onMapChange: onMapChangeUnwrapped, relayKeyboardEvent } = useCompositeRoot({
+        itemSizes,
+        cols,
+        loopFocus,
+        onLoop,
+        dense,
+        orientation,
+        highlightedIndex: highlightedIndexProp,
+        onHighlightedIndexChange: onHighlightedIndexChangeProp,
+        rootRef,
+        stopEventPropagation,
+        enableHomeAndEndKeys,
+        direction,
+        disabledIndices,
+        modifierKeys
+    });
+    const element = useRenderElement(tag, componentProps, {
+        state,
+        ref: refs,
+        props: [
+            defaultProps,
+            ...props,
+            elementProps
+        ],
+        stateAttributesMapping
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            highlightedIndex,
+            onHighlightedIndexChange,
+            highlightItemOnHover,
+            relayKeyboardEvent
+        }), [
+        highlightedIndex,
+        onHighlightedIndexChange,
+        highlightItemOnHover,
+        relayKeyboardEvent
+    ]);
+    return /*#__PURE__*/ jsx(CompositeRootContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(CompositeList, {
+            elementsRef: elementsRef,
+            onMapChange: (newMap)=>{
+                onMapChangeProp?.(newMap);
+                onMapChangeUnwrapped(newMap);
+            },
+            children: element
+        })
+    });
+}
+export { CompositeRoot };

package/dist/9189.js

@@ -0,0 +1,158 @@
+import { useCompositeRootContext } from "./8724.js";
+import { useIsoLayoutEffect, SafeReact } from "./6499.js";
+import { error } from "./4026.js";
+import { mergeProps, makeEventPreventable } from "./8272.js";
+import { useStableCallback } from "./7541.js";
+import { isHTMLElement } from "./3829.js";
+import * as __rspack_external_react from "react";
+function useFocusableWhenDisabled(parameters) {
+    const { focusableWhenDisabled, disabled, composite = false, tabIndex: tabIndexProp = 0, isNativeButton } = parameters;
+    const isFocusableComposite = composite && false !== focusableWhenDisabled;
+    const isNonFocusableComposite = composite && false === focusableWhenDisabled;
+    const props = __rspack_external_react.useMemo(()=>{
+        const additionalProps = {
+            onKeyDown (event) {
+                if (disabled && focusableWhenDisabled && 'Tab' !== event.key) event.preventDefault();
+            }
+        };
+        if (!composite) {
+            additionalProps.tabIndex = tabIndexProp;
+            if (!isNativeButton && disabled) additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
+        }
+        if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled) additionalProps['aria-disabled'] = disabled;
+        if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) additionalProps.disabled = disabled;
+        return additionalProps;
+    }, [
+        composite,
+        disabled,
+        focusableWhenDisabled,
+        isFocusableComposite,
+        isNonFocusableComposite,
+        isNativeButton,
+        tabIndexProp
+    ]);
+    return {
+        props
+    };
+}
+function useButton(parameters = {}) {
+    const { disabled = false, focusableWhenDisabled, tabIndex = 0, native: isNativeButton = true, composite: compositeProp } = parameters;
+    const elementRef = __rspack_external_react.useRef(null);
+    const compositeRootContext = useCompositeRootContext(true);
+    const isCompositeItem = compositeProp ?? void 0 !== compositeRootContext;
+    const { props: focusableWhenDisabledProps } = useFocusableWhenDisabled({
+        focusableWhenDisabled,
+        disabled,
+        composite: isCompositeItem,
+        tabIndex,
+        isNativeButton
+    });
+    if ('production' !== process.env.NODE_ENV) __rspack_external_react.useEffect(()=>{
+        if (!elementRef.current) return;
+        const isButtonTag = isButtonElement(elementRef.current);
+        if (isNativeButton) {
+            if (!isButtonTag) {
+                const ownerStackMessage = SafeReact.captureOwnerStack?.() || '';
+                const message = "A component that acts as a button expected a native <button> because the `nativeButton` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the `render` prop, or set `nativeButton` to `false`.";
+                error(`${message}${ownerStackMessage}`);
+            }
+        } else if (isButtonTag) {
+            const ownerStackMessage = SafeReact.captureOwnerStack?.() || '';
+            const message = "A component that acts as a button expected a non-<button> because the `nativeButton` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as `role` or `aria-disabled`). Use a non-<button> in the `render` prop, or set `nativeButton` to `true`.";
+            error(`${message}${ownerStackMessage}`);
+        }
+    }, [
+        isNativeButton
+    ]);
+    const updateDisabled = __rspack_external_react.useCallback(()=>{
+        const element = elementRef.current;
+        if (!isButtonElement(element)) return;
+        if (isCompositeItem && disabled && void 0 === focusableWhenDisabledProps.disabled && element.disabled) element.disabled = false;
+    }, [
+        disabled,
+        focusableWhenDisabledProps.disabled,
+        isCompositeItem
+    ]);
+    useIsoLayoutEffect(updateDisabled, [
+        updateDisabled
+    ]);
+    const getButtonProps = __rspack_external_react.useCallback((externalProps = {})=>{
+        const { onClick: externalOnClick, onMouseDown: externalOnMouseDown, onKeyUp: externalOnKeyUp, onKeyDown: externalOnKeyDown, onPointerDown: externalOnPointerDown, ...otherExternalProps } = externalProps;
+        return mergeProps({
+            onClick (event) {
+                if (disabled) return void event.preventDefault();
+                externalOnClick?.(event);
+            },
+            onMouseDown (event) {
+                if (!disabled) externalOnMouseDown?.(event);
+            },
+            onKeyDown (event) {
+                if (disabled) return;
+                makeEventPreventable(event);
+                externalOnKeyDown?.(event);
+                if (event.baseUIHandlerPrevented) return;
+                const isCurrentTarget = event.target === event.currentTarget;
+                const currentTarget = event.currentTarget;
+                const isButton = isButtonElement(currentTarget);
+                const isLink = !isNativeButton && isValidLinkElement(currentTarget);
+                const shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink);
+                const isEnterKey = 'Enter' === event.key;
+                const isSpaceKey = ' ' === event.key;
+                const role = currentTarget.getAttribute('role');
+                const isTextNavigationRole = role?.startsWith('menuitem') || 'option' === role || 'gridcell' === role;
+                if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+                    if (event.defaultPrevented && isTextNavigationRole) return;
+                    event.preventDefault();
+                    if (isLink || isNativeButton && isButton) {
+                        currentTarget.click();
+                        event.preventBaseUIHandler();
+                    } else if (shouldClick) {
+                        externalOnClick?.(event);
+                        event.preventBaseUIHandler();
+                    }
+                    return;
+                }
+                if (shouldClick) {
+                    if (!isNativeButton && (isSpaceKey || isEnterKey)) event.preventDefault();
+                    if (!isNativeButton && isEnterKey) externalOnClick?.(event);
+                }
+            },
+            onKeyUp (event) {
+                if (disabled) return;
+                makeEventPreventable(event);
+                externalOnKeyUp?.(event);
+                if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && ' ' === event.key) return void event.preventDefault();
+                if (event.baseUIHandlerPrevented) return;
+                if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && ' ' === event.key) externalOnClick?.(event);
+            },
+            onPointerDown (event) {
+                if (disabled) return void event.preventDefault();
+                externalOnPointerDown?.(event);
+            }
+        }, isNativeButton ? {
+            type: 'button'
+        } : {
+            role: 'button'
+        }, focusableWhenDisabledProps, otherExternalProps);
+    }, [
+        disabled,
+        focusableWhenDisabledProps,
+        isCompositeItem,
+        isNativeButton
+    ]);
+    const buttonRef = useStableCallback((element)=>{
+        elementRef.current = element;
+        updateDisabled();
+    });
+    return {
+        getButtonProps,
+        buttonRef
+    };
+}
+function isButtonElement(elem) {
+    return isHTMLElement(elem) && 'BUTTON' === elem.tagName;
+}
+function isValidLinkElement(elem) {
+    return Boolean(elem?.tagName === 'A' && elem?.href);
+}
+export { useButton, useFocusableWhenDisabled };

package/dist/9255.js

@@ -0,0 +1,136 @@
+import { jsx } from "react/jsx-runtime";
+import { useStableCallback } from "./7541.js";
+import { useRefWithInit } from "./8272.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { CompositeListContext } from "./5036.js";
+import * as __rspack_external_react from "react";
+function CompositeList(props) {
+    const { children, elementsRef, labelsRef, onMapChange: onMapChangeProp } = props;
+    const onMapChange = useStableCallback(onMapChangeProp);
+    const nextIndexRef = __rspack_external_react.useRef(0);
+    const listeners = useRefWithInit(createListeners).current;
+    const map = useRefWithInit(createMap).current;
+    const [mapTick, setMapTick] = __rspack_external_react.useState(0);
+    const lastTickRef = __rspack_external_react.useRef(mapTick);
+    const register = useStableCallback((node, metadata)=>{
+        map.set(node, metadata ?? null);
+        lastTickRef.current += 1;
+        setMapTick(lastTickRef.current);
+    });
+    const unregister = useStableCallback((node)=>{
+        map.delete(node);
+        lastTickRef.current += 1;
+        setMapTick(lastTickRef.current);
+    });
+    const sortedMap = __rspack_external_react.useMemo(()=>{
+        disableEslintWarning(mapTick);
+        const newMap = new Map();
+        const sortedNodes = Array.from(map.keys()).filter((node)=>node.isConnected).sort(sortByDocumentPosition);
+        sortedNodes.forEach((node, index)=>{
+            const metadata = map.get(node) ?? {};
+            newMap.set(node, {
+                ...metadata,
+                index
+            });
+        });
+        return newMap;
+    }, [
+        map,
+        mapTick
+    ]);
+    useIsoLayoutEffect(()=>{
+        if ('function' != typeof MutationObserver || 0 === sortedMap.size) return;
+        const mutationObserver = new MutationObserver((entries)=>{
+            const diff = new Set();
+            const updateDiff = (node)=>diff.has(node) ? diff.delete(node) : diff.add(node);
+            entries.forEach((entry)=>{
+                entry.removedNodes.forEach(updateDiff);
+                entry.addedNodes.forEach(updateDiff);
+            });
+            if (0 === diff.size) {
+                lastTickRef.current += 1;
+                setMapTick(lastTickRef.current);
+            }
+        });
+        sortedMap.forEach((_, node)=>{
+            if (node.parentElement) mutationObserver.observe(node.parentElement, {
+                childList: true
+            });
+        });
+        return ()=>{
+            mutationObserver.disconnect();
+        };
+    }, [
+        sortedMap
+    ]);
+    useIsoLayoutEffect(()=>{
+        const shouldUpdateLengths = lastTickRef.current === mapTick;
+        if (shouldUpdateLengths) {
+            if (elementsRef.current.length !== sortedMap.size) elementsRef.current.length = sortedMap.size;
+            if (labelsRef && labelsRef.current.length !== sortedMap.size) labelsRef.current.length = sortedMap.size;
+            nextIndexRef.current = sortedMap.size;
+        }
+        onMapChange(sortedMap);
+    }, [
+        onMapChange,
+        sortedMap,
+        elementsRef,
+        labelsRef,
+        mapTick
+    ]);
+    useIsoLayoutEffect(()=>()=>{
+            elementsRef.current = [];
+        }, [
+        elementsRef
+    ]);
+    useIsoLayoutEffect(()=>()=>{
+            if (labelsRef) labelsRef.current = [];
+        }, [
+        labelsRef
+    ]);
+    const subscribeMapChange = useStableCallback((fn)=>{
+        listeners.add(fn);
+        return ()=>{
+            listeners.delete(fn);
+        };
+    });
+    useIsoLayoutEffect(()=>{
+        listeners.forEach((l)=>l(sortedMap));
+    }, [
+        listeners,
+        sortedMap
+    ]);
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            register,
+            unregister,
+            subscribeMapChange,
+            elementsRef,
+            labelsRef,
+            nextIndexRef
+        }), [
+        register,
+        unregister,
+        subscribeMapChange,
+        elementsRef,
+        labelsRef,
+        nextIndexRef
+    ]);
+    return /*#__PURE__*/ jsx(CompositeListContext.Provider, {
+        value: contextValue,
+        children: children
+    });
+}
+function createMap() {
+    return new Map();
+}
+function createListeners() {
+    return new Set();
+}
+function sortByDocumentPosition(a, b) {
+    const position = a.compareDocumentPosition(b);
+    if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) return -1;
+    if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) return 1;
+    return 0;
+}
+function disableEslintWarning(_) {}
+export { CompositeList };