@coopdigital/react 0.49.1 → 0.50.0

package/dist/node_modules/react-day-picker/dist/esm/utils/convertMatchersToTimeZone.js

@@ -0,0 +1,57 @@
+import { toTimeZone } from './toTimeZone.js';
+import { isDateRange, isDateInterval, isDateAfterType, isDateBeforeType } from './typeguards.js';
+
+function convertMatcher(matcher, timeZone) {
+    if (typeof matcher === "boolean" || typeof matcher === "function") {
+        return matcher;
+    }
+    if (matcher instanceof Date) {
+        return toTimeZone(matcher, timeZone);
+    }
+    if (Array.isArray(matcher)) {
+        return matcher.map((value) => value instanceof Date ? toTimeZone(value, timeZone) : value);
+    }
+    if (isDateRange(matcher)) {
+        return {
+            ...matcher,
+            from: matcher.from ? toTimeZone(matcher.from, timeZone) : matcher.from,
+            to: matcher.to ? toTimeZone(matcher.to, timeZone) : matcher.to,
+        };
+    }
+    if (isDateInterval(matcher)) {
+        return {
+            before: toTimeZone(matcher.before, timeZone),
+            after: toTimeZone(matcher.after, timeZone),
+        };
+    }
+    if (isDateAfterType(matcher)) {
+        return {
+            after: toTimeZone(matcher.after, timeZone),
+        };
+    }
+    if (isDateBeforeType(matcher)) {
+        return {
+            before: toTimeZone(matcher.before, timeZone),
+        };
+    }
+    return matcher;
+}
+/**
+ * Convert any {@link Matcher} or array of matchers to the specified time zone.
+ *
+ * @param matchers - The matcher or matchers to convert.
+ * @param timeZone - The target IANA time zone.
+ * @returns The converted matcher(s).
+ * @group Utilities
+ */
+function convertMatchersToTimeZone(matchers, timeZone) {
+    if (!matchers) {
+        return matchers;
+    }
+    if (Array.isArray(matchers)) {
+        return matchers.map((matcher) => convertMatcher(matcher, timeZone));
+    }
+    return convertMatcher(matchers, timeZone);
+}
+
+export { convertMatchersToTimeZone };

package/dist/node_modules/react-day-picker/dist/esm/utils/dateMatchModifiers.js

@@ -0,0 +1,62 @@
+import { defaultDateLib } from '../classes/DateLib.js';
+import { rangeIncludesDate } from './rangeIncludesDate.js';
+import { isDatesArray, isDateRange, isDayOfWeekType, isDateInterval, isDateAfterType, isDateBeforeType } from './typeguards.js';
+
+/**
+ * Checks if a given date matches at least one of the specified {@link Matcher}.
+ *
+ * @param date - The date to check.
+ * @param matchers - The matchers to check against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the date matches any of the matchers, otherwise `false`.
+ * @group Utilities
+ */
+function dateMatchModifiers(date, matchers, dateLib = defaultDateLib) {
+    const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
+    const { isSameDay, differenceInCalendarDays, isAfter } = dateLib;
+    return matchersArr.some((matcher) => {
+        if (typeof matcher === "boolean") {
+            return matcher;
+        }
+        if (dateLib.isDate(matcher)) {
+            return isSameDay(date, matcher);
+        }
+        if (isDatesArray(matcher, dateLib)) {
+            return matcher.some((matcherDate) => isSameDay(date, matcherDate));
+        }
+        if (isDateRange(matcher)) {
+            return rangeIncludesDate(matcher, date, false, dateLib);
+        }
+        if (isDayOfWeekType(matcher)) {
+            if (!Array.isArray(matcher.dayOfWeek)) {
+                return matcher.dayOfWeek === date.getDay();
+            }
+            return matcher.dayOfWeek.includes(date.getDay());
+        }
+        if (isDateInterval(matcher)) {
+            const diffBefore = differenceInCalendarDays(matcher.before, date);
+            const diffAfter = differenceInCalendarDays(matcher.after, date);
+            const isDayBefore = diffBefore > 0;
+            const isDayAfter = diffAfter < 0;
+            const isClosedInterval = isAfter(matcher.before, matcher.after);
+            if (isClosedInterval) {
+                return isDayAfter && isDayBefore;
+            }
+            else {
+                return isDayBefore || isDayAfter;
+            }
+        }
+        if (isDateAfterType(matcher)) {
+            return differenceInCalendarDays(date, matcher.after) > 0;
+        }
+        if (isDateBeforeType(matcher)) {
+            return differenceInCalendarDays(matcher.before, date) > 0;
+        }
+        if (typeof matcher === "function") {
+            return matcher(date);
+        }
+        return false;
+    });
+}
+
+export { dateMatchModifiers };

package/dist/node_modules/react-day-picker/dist/esm/utils/rangeContainsDayOfWeek.js

@@ -0,0 +1,30 @@
+import { defaultDateLib } from '../classes/DateLib.js';
+
+/**
+ * Checks if a date range contains one or more specified days of the week.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param dayOfWeek - The day(s) of the week to check for (`0-6`, where `0` is
+ *   Sunday).
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains the specified day(s) of the week,
+ *   otherwise `false`.
+ * @group Utilities
+ */
+function rangeContainsDayOfWeek(range, dayOfWeek, dateLib = defaultDateLib) {
+    const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
+    let date = range.from;
+    const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+    // iterate at maximum one week or the total days if the range is shorter than one week
+    const totalDaysLimit = Math.min(totalDays, 6);
+    for (let i = 0; i <= totalDaysLimit; i++) {
+        if (dayOfWeekArr.includes(date.getDay())) {
+            return true;
+        }
+        date = dateLib.addDays(date, 1);
+    }
+    return false;
+}
+
+export { rangeContainsDayOfWeek };

package/dist/node_modules/react-day-picker/dist/esm/utils/rangeContainsModifiers.js

@@ -0,0 +1,74 @@
+import { defaultDateLib } from '../classes/DateLib.js';
+import { dateMatchModifiers } from './dateMatchModifiers.js';
+import { rangeContainsDayOfWeek } from './rangeContainsDayOfWeek.js';
+import { rangeIncludesDate } from './rangeIncludesDate.js';
+import { rangeOverlaps } from './rangeOverlaps.js';
+import { isDatesArray, isDateRange, isDayOfWeekType, isDateInterval, isDateAfterType, isDateBeforeType } from './typeguards.js';
+
+/**
+ * Checks if a date range contains dates that match the given modifiers.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param modifiers - The modifiers to match against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains matching dates, otherwise `false`.
+ * @group Utilities
+ */
+function rangeContainsModifiers(range, modifiers, dateLib = defaultDateLib) {
+    const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
+    // Defer function matchers evaluation as they are the least performant.
+    const nonFunctionMatchers = matchers.filter((matcher) => typeof matcher !== "function");
+    const nonFunctionMatchersResult = nonFunctionMatchers.some((matcher) => {
+        if (typeof matcher === "boolean")
+            return matcher;
+        if (dateLib.isDate(matcher)) {
+            return rangeIncludesDate(range, matcher, false, dateLib);
+        }
+        if (isDatesArray(matcher, dateLib)) {
+            return matcher.some((date) => rangeIncludesDate(range, date, false, dateLib));
+        }
+        if (isDateRange(matcher)) {
+            if (matcher.from && matcher.to) {
+                return rangeOverlaps(range, { from: matcher.from, to: matcher.to }, dateLib);
+            }
+            return false;
+        }
+        if (isDayOfWeekType(matcher)) {
+            return rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
+        }
+        if (isDateInterval(matcher)) {
+            const isClosedInterval = dateLib.isAfter(matcher.before, matcher.after);
+            if (isClosedInterval) {
+                return rangeOverlaps(range, {
+                    from: dateLib.addDays(matcher.after, 1),
+                    to: dateLib.addDays(matcher.before, -1),
+                }, dateLib);
+            }
+            return (dateMatchModifiers(range.from, matcher, dateLib) ||
+                dateMatchModifiers(range.to, matcher, dateLib));
+        }
+        if (isDateAfterType(matcher) || isDateBeforeType(matcher)) {
+            return (dateMatchModifiers(range.from, matcher, dateLib) ||
+                dateMatchModifiers(range.to, matcher, dateLib));
+        }
+        return false;
+    });
+    if (nonFunctionMatchersResult) {
+        return true;
+    }
+    const functionMatchers = matchers.filter((matcher) => typeof matcher === "function");
+    if (functionMatchers.length) {
+        let date = range.from;
+        const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+        for (let i = 0; i <= totalDays; i++) {
+            if (functionMatchers.some((matcher) => matcher(date))) {
+                return true;
+            }
+            date = dateLib.addDays(date, 1);
+        }
+    }
+    return false;
+}
+
+export { rangeContainsModifiers };

package/dist/node_modules/react-day-picker/dist/esm/utils/rangeIncludesDate.js

@@ -0,0 +1,35 @@
+import { defaultDateLib } from '../classes/DateLib.js';
+
+/**
+ * Checks if a given date is within a specified date range.
+ *
+ * @since 9.0.0
+ * @param range - The date range to check against.
+ * @param date - The date to check.
+ * @param excludeEnds - If `true`, the range's start and end dates are excluded.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the date is within the range, otherwise `false`.
+ * @group Utilities
+ */
+function rangeIncludesDate(range, date, excludeEnds = false, dateLib = defaultDateLib) {
+    let { from, to } = range;
+    const { differenceInCalendarDays, isSameDay } = dateLib;
+    if (from && to) {
+        const isRangeInverted = differenceInCalendarDays(to, from) < 0;
+        if (isRangeInverted) {
+            [from, to] = [to, from];
+        }
+        const isInRange = differenceInCalendarDays(date, from) >= (excludeEnds ? 1 : 0) &&
+            differenceInCalendarDays(to, date) >= (excludeEnds ? 1 : 0);
+        return isInRange;
+    }
+    if (!excludeEnds && to) {
+        return isSameDay(to, date);
+    }
+    if (!excludeEnds && from) {
+        return isSameDay(from, date);
+    }
+    return false;
+}
+
+export { rangeIncludesDate };

package/dist/node_modules/react-day-picker/dist/esm/utils/rangeOverlaps.js

@@ -0,0 +1,21 @@
+import { rangeIncludesDate } from './rangeIncludesDate.js';
+import { defaultDateLib } from '../classes/DateLib.js';
+
+/**
+ * Determines if two date ranges overlap.
+ *
+ * @since 9.2.2
+ * @param rangeLeft - The first date range.
+ * @param rangeRight - The second date range.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the ranges overlap, otherwise `false`.
+ * @group Utilities
+ */
+function rangeOverlaps(rangeLeft, rangeRight, dateLib = defaultDateLib) {
+    return (rangeIncludesDate(rangeLeft, rangeRight.from, false, dateLib) ||
+        rangeIncludesDate(rangeLeft, rangeRight.to, false, dateLib) ||
+        rangeIncludesDate(rangeRight, rangeLeft.from, false, dateLib) ||
+        rangeIncludesDate(rangeRight, rangeLeft.to, false, dateLib));
+}
+
+export { rangeOverlaps };

package/dist/node_modules/react-day-picker/dist/esm/utils/toTimeZone.js

@@ -0,0 +1,16 @@
+import { TZDate } from '../../../../@date-fns/tz/date/index.js';
+import '../../../../@date-fns/tz/date/mini.js';
+
+/**
+ * Convert a {@link Date} or {@link TZDate} instance to the given time zone.
+ * Reuses the same instance when it is already a {@link TZDate} using the target
+ * time zone to avoid extra allocations.
+ */
+function toTimeZone(date, timeZone) {
+    if (date instanceof TZDate && date.timeZone === timeZone) {
+        return date;
+    }
+    return new TZDate(date, timeZone);
+}
+
+export { toTimeZone };

package/dist/node_modules/react-day-picker/dist/esm/utils/typeguards.js

@@ -0,0 +1,66 @@
+/**
+ * Checks if the given value is of type {@link DateInterval}.
+ *
+ * @param matcher - The value to check.
+ * @returns `true` if the value is a {@link DateInterval}, otherwise `false`.
+ * @group Utilities
+ */
+function isDateInterval(matcher) {
+    return Boolean(matcher &&
+        typeof matcher === "object" &&
+        "before" in matcher &&
+        "after" in matcher);
+}
+/**
+ * Checks if the given value is of type {@link DateRange}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DateRange}, otherwise `false`.
+ * @group Utilities
+ */
+function isDateRange(value) {
+    return Boolean(value && typeof value === "object" && "from" in value);
+}
+/**
+ * Checks if the given value is of type {@link DateAfter}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DateAfter}, otherwise `false`.
+ * @group Utilities
+ */
+function isDateAfterType(value) {
+    return Boolean(value && typeof value === "object" && "after" in value);
+}
+/**
+ * Checks if the given value is of type {@link DateBefore}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DateBefore}, otherwise `false`.
+ * @group Utilities
+ */
+function isDateBeforeType(value) {
+    return Boolean(value && typeof value === "object" && "before" in value);
+}
+/**
+ * Checks if the given value is of type {@link DayOfWeek}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DayOfWeek}, otherwise `false`.
+ * @group Utilities
+ */
+function isDayOfWeekType(value) {
+    return Boolean(value && typeof value === "object" && "dayOfWeek" in value);
+}
+/**
+ * Checks if the given value is an array of valid dates.
+ *
+ * @private
+ * @param value - The value to check.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the value is an array of valid dates, otherwise `false`.
+ */
+function isDatesArray(value, dateLib) {
+    return Array.isArray(value) && value.every(dateLib.isDate);
+}
+
+export { isDateAfterType, isDateBeforeType, isDateInterval, isDateRange, isDatesArray, isDayOfWeekType };

package/dist/node_modules/react-remove-scroll/dist/es2015/Combination.js

@@ -0,0 +1,9 @@
+import { __assign } from '../../../tslib/tslib.es6.js';
+import * as React from 'react';
+import { RemoveScroll } from './UI.js';
+import SideCar from './sidecar.js';
+
+var ReactRemoveScroll = React.forwardRef(function (props, ref) { return (React.createElement(RemoveScroll, __assign({}, props, { ref: ref, sideCar: SideCar }))); });
+ReactRemoveScroll.classNames = RemoveScroll.classNames;
+
+export { ReactRemoveScroll as default };

package/dist/node_modules/react-remove-scroll/dist/es2015/SideEffect.js

@@ -0,0 +1,167 @@
+import { __spreadArray } from '../../../tslib/tslib.es6.js';
+import * as React from 'react';
+import { RemoveScrollBar } from '../../../react-remove-scroll-bar/dist/es2015/component.js';
+import { styleSingleton } from '../../../react-style-singleton/dist/es2015/component.js';
+import { nonPassive } from './aggresiveCapture.js';
+import { locationCouldBeScrolled, handleScroll } from './handleScroll.js';
+
+var getTouchXY = function (event) {
+    return 'changedTouches' in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
+};
+var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };
+var extractRef = function (ref) {
+    return ref && 'current' in ref ? ref.current : ref;
+};
+var deltaCompare = function (x, y) { return x[0] === y[0] && x[1] === y[1]; };
+var generateStyle = function (id) { return "\n  .block-interactivity-".concat(id, " {pointer-events: none;}\n  .allow-interactivity-").concat(id, " {pointer-events: all;}\n"); };
+var idCounter = 0;
+var lockStack = [];
+function RemoveScrollSideCar(props) {
+    var shouldPreventQueue = React.useRef([]);
+    var touchStartRef = React.useRef([0, 0]);
+    var activeAxis = React.useRef();
+    var id = React.useState(idCounter++)[0];
+    var Style = React.useState(styleSingleton)[0];
+    var lastProps = React.useRef(props);
+    React.useEffect(function () {
+        lastProps.current = props;
+    }, [props]);
+    React.useEffect(function () {
+        if (props.inert) {
+            document.body.classList.add("block-interactivity-".concat(id));
+            var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);
+            allow_1.forEach(function (el) { return el.classList.add("allow-interactivity-".concat(id)); });
+            return function () {
+                document.body.classList.remove("block-interactivity-".concat(id));
+                allow_1.forEach(function (el) { return el.classList.remove("allow-interactivity-".concat(id)); });
+            };
+        }
+        return;
+    }, [props.inert, props.lockRef.current, props.shards]);
+    var shouldCancelEvent = React.useCallback(function (event, parent) {
+        if (('touches' in event && event.touches.length === 2) || (event.type === 'wheel' && event.ctrlKey)) {
+            return !lastProps.current.allowPinchZoom;
+        }
+        var touch = getTouchXY(event);
+        var touchStart = touchStartRef.current;
+        var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];
+        var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];
+        var currentAxis;
+        var target = event.target;
+        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';
+        // allow horizontal touch move on Range inputs. They will not cause any scroll
+        if ('touches' in event && moveDirection === 'h' && target.type === 'range') {
+            return false;
+        }
+        // allow drag selection (iOS); check if selection's anchorNode is the same as target or contains target
+        var selection = window.getSelection();
+        var anchorNode = selection && selection.anchorNode;
+        var isTouchingSelection = anchorNode ? anchorNode === target || anchorNode.contains(target) : false;
+        if (isTouchingSelection) {
+            return false;
+        }
+        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
+        if (!canBeScrolledInMainDirection) {
+            return true;
+        }
+        if (canBeScrolledInMainDirection) {
+            currentAxis = moveDirection;
+        }
+        else {
+            currentAxis = moveDirection === 'v' ? 'h' : 'v';
+            canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
+            // other axis might be not scrollable
+        }
+        if (!canBeScrolledInMainDirection) {
+            return false;
+        }
+        if (!activeAxis.current && 'changedTouches' in event && (deltaX || deltaY)) {
+            activeAxis.current = currentAxis;
+        }
+        if (!currentAxis) {
+            return true;
+        }
+        var cancelingAxis = activeAxis.current || currentAxis;
+        return handleScroll(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY);
+    }, []);
+    var shouldPrevent = React.useCallback(function (_event) {
+        var event = _event;
+        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {
+            // not the last active
+            return;
+        }
+        var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);
+        var sourceEvent = shouldPreventQueue.current.filter(function (e) { return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta); })[0];
+        // self event, and should be canceled
+        if (sourceEvent && sourceEvent.should) {
+            if (event.cancelable) {
+                event.preventDefault();
+            }
+            return;
+        }
+        // outside or shard event
+        if (!sourceEvent) {
+            var shardNodes = (lastProps.current.shards || [])
+                .map(extractRef)
+                .filter(Boolean)
+                .filter(function (node) { return node.contains(event.target); });
+            var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;
+            if (shouldStop) {
+                if (event.cancelable) {
+                    event.preventDefault();
+                }
+            }
+        }
+    }, []);
+    var shouldCancel = React.useCallback(function (name, delta, target, should) {
+        var event = { name: name, delta: delta, target: target, should: should, shadowParent: getOutermostShadowParent(target) };
+        shouldPreventQueue.current.push(event);
+        setTimeout(function () {
+            shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) { return e !== event; });
+        }, 1);
+    }, []);
+    var scrollTouchStart = React.useCallback(function (event) {
+        touchStartRef.current = getTouchXY(event);
+        activeAxis.current = undefined;
+    }, []);
+    var scrollWheel = React.useCallback(function (event) {
+        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
+    }, []);
+    var scrollTouchMove = React.useCallback(function (event) {
+        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
+    }, []);
+    React.useEffect(function () {
+        lockStack.push(Style);
+        props.setCallbacks({
+            onScrollCapture: scrollWheel,
+            onWheelCapture: scrollWheel,
+            onTouchMoveCapture: scrollTouchMove,
+        });
+        document.addEventListener('wheel', shouldPrevent, nonPassive);
+        document.addEventListener('touchmove', shouldPrevent, nonPassive);
+        document.addEventListener('touchstart', scrollTouchStart, nonPassive);
+        return function () {
+            lockStack = lockStack.filter(function (inst) { return inst !== Style; });
+            document.removeEventListener('wheel', shouldPrevent, nonPassive);
+            document.removeEventListener('touchmove', shouldPrevent, nonPassive);
+            document.removeEventListener('touchstart', scrollTouchStart, nonPassive);
+        };
+    }, []);
+    var removeScrollBar = props.removeScrollBar, inert = props.inert;
+    return (React.createElement(React.Fragment, null,
+        inert ? React.createElement(Style, { styles: generateStyle(id) }) : null,
+        removeScrollBar ? React.createElement(RemoveScrollBar, { noRelative: props.noRelative, gapMode: props.gapMode }) : null));
+}
+function getOutermostShadowParent(node) {
+    var shadowParent = null;
+    while (node !== null) {
+        if (node instanceof ShadowRoot) {
+            shadowParent = node.host;
+            node = node.host;
+        }
+        node = node.parentNode;
+    }
+    return shadowParent;
+}
+
+export { RemoveScrollSideCar, getDeltaXY, getTouchXY };

package/dist/node_modules/react-remove-scroll/dist/es2015/UI.js

@@ -0,0 +1,38 @@
+import { __rest, __assign } from '../../../tslib/tslib.es6.js';
+import * as React from 'react';
+import { zeroRightClassName, fullWidthClassName } from '../../../react-remove-scroll-bar/dist/es2015/constants.js';
+import { effectCar } from './medium.js';
+import { useMergeRefs } from '../../../use-callback-ref/dist/es2015/useMergeRef.js';
+
+var nothing = function () {
+    return;
+};
+/**
+ * Removes scrollbar from the page and contain the scroll within the Lock
+ */
+var RemoveScroll = React.forwardRef(function (props, parentRef) {
+    var ref = React.useRef(null);
+    var _a = React.useState({
+        onScrollCapture: nothing,
+        onWheelCapture: nothing,
+        onTouchMoveCapture: nothing,
+    }), callbacks = _a[0], setCallbacks = _a[1];
+    var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noRelative = props.noRelative, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? 'div' : _b, gapMode = props.gapMode, rest = __rest(props, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]);
+    var SideCar = sideCar;
+    var containerRef = useMergeRefs([ref, parentRef]);
+    var containerProps = __assign(__assign({}, rest), callbacks);
+    return (React.createElement(React.Fragment, null,
+        enabled && (React.createElement(SideCar, { sideCar: effectCar, removeScrollBar: removeScrollBar, shards: shards, noRelative: noRelative, noIsolation: noIsolation, inert: inert, setCallbacks: setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref, gapMode: gapMode })),
+        forwardProps ? (React.cloneElement(React.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef }))) : (React.createElement(Container, __assign({}, containerProps, { className: className, ref: containerRef }), children))));
+});
+RemoveScroll.defaultProps = {
+    enabled: true,
+    removeScrollBar: true,
+    inert: false,
+};
+RemoveScroll.classNames = {
+    fullWidth: fullWidthClassName,
+    zeroRight: zeroRightClassName,
+};
+
+export { RemoveScroll };

package/dist/node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js

@@ -0,0 +1,21 @@
+var passiveSupported = false;
+if (typeof window !== 'undefined') {
+    try {
+        var options = Object.defineProperty({}, 'passive', {
+            get: function () {
+                passiveSupported = true;
+                return true;
+            },
+        });
+        // @ts-ignore
+        window.addEventListener('test', options, options);
+        // @ts-ignore
+        window.removeEventListener('test', options, options);
+    }
+    catch (err) {
+        passiveSupported = false;
+    }
+}
+var nonPassive = passiveSupported ? { passive: false } : false;
+
+export { nonPassive };