@noodleseed/one 0.32.1 → 0.34.0

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

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveScrollSideCar = exports.getDeltaXY = exports.getTouchXY = void 0;
+var tslib_1 = require("tslib");
+var React = tslib_1.__importStar(require("react"));
+var react_remove_scroll_bar_1 = require("react-remove-scroll-bar");
+var react_style_singleton_1 = require("react-style-singleton");
+var aggresiveCapture_1 = require("./aggresiveCapture");
+var handleScroll_1 = require("./handleScroll");
+var getTouchXY = function (event) {
+    return 'changedTouches' in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
+};
+exports.getTouchXY = getTouchXY;
+var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };
+exports.getDeltaXY = getDeltaXY;
+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(react_style_singleton_1.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 = tslib_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 = (0, exports.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 = (0, handleScroll_1.locationCouldBeScrolled)(moveDirection, target);
+        if (!canBeScrolledInMainDirection) {
+            return true;
+        }
+        if (canBeScrolledInMainDirection) {
+            currentAxis = moveDirection;
+        }
+        else {
+            currentAxis = moveDirection === 'v' ? 'h' : 'v';
+            canBeScrolledInMainDirection = (0, handleScroll_1.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 (0, handleScroll_1.handleScroll)(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY, true);
+    }, []);
+    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 ? (0, exports.getDeltaXY)(event) : (0, exports.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 = (0, exports.getTouchXY)(event);
+        activeAxis.current = undefined;
+    }, []);
+    var scrollWheel = React.useCallback(function (event) {
+        shouldCancel(event.type, (0, exports.getDeltaXY)(event), event.target, shouldCancelEvent(event, props.lockRef.current));
+    }, []);
+    var scrollTouchMove = React.useCallback(function (event) {
+        shouldCancel(event.type, (0, exports.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, aggresiveCapture_1.nonPassive);
+        document.addEventListener('touchmove', shouldPrevent, aggresiveCapture_1.nonPassive);
+        document.addEventListener('touchstart', scrollTouchStart, aggresiveCapture_1.nonPassive);
+        return function () {
+            lockStack = lockStack.filter(function (inst) { return inst !== Style; });
+            document.removeEventListener('wheel', shouldPrevent, aggresiveCapture_1.nonPassive);
+            document.removeEventListener('touchmove', shouldPrevent, aggresiveCapture_1.nonPassive);
+            document.removeEventListener('touchstart', scrollTouchStart, aggresiveCapture_1.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(react_remove_scroll_bar_1.RemoveScrollBar, { noRelative: props.noRelative, gapMode: props.gapMode }) : null));
+}
+exports.RemoveScrollSideCar = RemoveScrollSideCar;
+function getOutermostShadowParent(node) {
+    var shadowParent = null;
+    while (node !== null) {
+        if (node instanceof ShadowRoot) {
+            shadowParent = node.host;
+            node = node.host;
+        }
+        node = node.parentNode;
+    }
+    return shadowParent;
+}

package/node_modules/react-remove-scroll/dist/es5/UI.d.ts

@@ -0,0 +1,7 @@
+import { RemoveScrollUIType, IRemoveScrollSelfProps } from './types';
+export type { IRemoveScrollSelfProps, RemoveScrollUIType };
+/**
+ * Removes scrollbar from the page and contain the scroll within the Lock
+ */
+declare const RemoveScroll: RemoveScrollUIType;
+export { RemoveScroll };

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveScroll = void 0;
+var tslib_1 = require("tslib");
+var React = tslib_1.__importStar(require("react"));
+var constants_1 = require("react-remove-scroll-bar/constants");
+var use_callback_ref_1 = require("use-callback-ref");
+var medium_1 = require("./medium");
+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 = tslib_1.__rest(props, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]);
+    var SideCar = sideCar;
+    var containerRef = (0, use_callback_ref_1.useMergeRefs)([ref, parentRef]);
+    var containerProps = tslib_1.__assign(tslib_1.__assign({}, rest), callbacks);
+    return (React.createElement(React.Fragment, null,
+        enabled && (React.createElement(SideCar, { sideCar: medium_1.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), tslib_1.__assign(tslib_1.__assign({}, containerProps), { ref: containerRef }))) : (React.createElement(Container, tslib_1.__assign({}, containerProps, { className: className, ref: containerRef }), children))));
+});
+exports.RemoveScroll = RemoveScroll;
+RemoveScroll.defaultProps = {
+    enabled: true,
+    removeScrollBar: true,
+    inert: false,
+};
+RemoveScroll.classNames = {
+    fullWidth: constants_1.fullWidthClassName,
+    zeroRight: constants_1.zeroRightClassName,
+};

package/node_modules/react-remove-scroll/dist/es5/aggresiveCapture.d.ts

@@ -0,0 +1,3 @@
+export declare const nonPassive: boolean | {
+    passive: boolean;
+};

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonPassive = void 0;
+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;
+    }
+}
+exports.nonPassive = passiveSupported ? { passive: false } : false;

package/node_modules/react-remove-scroll/dist/es5/handleScroll.d.ts

@@ -0,0 +1,3 @@
+import { Axis } from './types';
+export declare const locationCouldBeScrolled: (axis: Axis, node: HTMLElement) => boolean;
+export declare const handleScroll: (axis: Axis, endTarget: HTMLElement, event: any, sourceDelta: number, noOverscroll: boolean) => boolean;

package/node_modules/react-remove-scroll/dist/es5/handleScroll.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleScroll = exports.locationCouldBeScrolled = void 0;
+var alwaysContainsScroll = function (node) {
+    // textarea will always _contain_ scroll inside self. It only can be hidden
+    return node.tagName === 'TEXTAREA';
+};
+var elementCanBeScrolled = function (node, overflow) {
+    if (!(node instanceof Element)) {
+        return false;
+    }
+    var styles = window.getComputedStyle(node);
+    return (
+    // not-not-scrollable
+    styles[overflow] !== 'hidden' &&
+        // contains scroll inside self
+        !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === 'visible'));
+};
+var elementCouldBeVScrolled = function (node) { return elementCanBeScrolled(node, 'overflowY'); };
+var elementCouldBeHScrolled = function (node) { return elementCanBeScrolled(node, 'overflowX'); };
+var locationCouldBeScrolled = function (axis, node) {
+    var ownerDocument = node.ownerDocument;
+    var current = node;
+    do {
+        // Skip over shadow root
+        if (typeof ShadowRoot !== 'undefined' && current instanceof ShadowRoot) {
+            current = current.host;
+        }
+        var isScrollable = elementCouldBeScrolled(axis, current);
+        if (isScrollable) {
+            var _a = getScrollVariables(axis, current), scrollHeight = _a[1], clientHeight = _a[2];
+            if (scrollHeight > clientHeight) {
+                return true;
+            }
+        }
+        current = current.parentNode;
+    } while (current && current !== ownerDocument.body);
+    return false;
+};
+exports.locationCouldBeScrolled = locationCouldBeScrolled;
+var getVScrollVariables = function (_a) {
+    var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;
+    return [
+        scrollTop,
+        scrollHeight,
+        clientHeight,
+    ];
+};
+var getHScrollVariables = function (_a) {
+    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;
+    return [
+        scrollLeft,
+        scrollWidth,
+        clientWidth,
+    ];
+};
+var elementCouldBeScrolled = function (axis, node) {
+    return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);
+};
+var getScrollVariables = function (axis, node) {
+    return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);
+};
+var getDirectionFactor = function (axis, direction) {
+    /**
+     * If the element's direction is rtl (right-to-left), then scrollLeft is 0 when the scrollbar is at its rightmost position,
+     * and then increasingly negative as you scroll towards the end of the content.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft
+     */
+    return axis === 'h' && direction === 'rtl' ? -1 : 1;
+};
+var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {
+    var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);
+    var delta = directionFactor * sourceDelta;
+    // find scrollable target
+    var target = event.target;
+    var targetInLock = endTarget.contains(target);
+    var shouldCancelScroll = false;
+    var isDeltaPositive = delta > 0;
+    var availableScroll = 0;
+    var availableScrollTop = 0;
+    do {
+        if (!target) {
+            break;
+        }
+        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];
+        var elementScroll = scroll_1 - capacity - directionFactor * position;
+        if (position || elementScroll) {
+            if (elementCouldBeScrolled(axis, target)) {
+                availableScroll += elementScroll;
+                availableScrollTop += position;
+            }
+        }
+        var parent_1 = target.parentNode;
+        // we will "bubble" from ShadowDom in case we are, or just to the parent in normal case
+        // this is the same logic used in focus-lock
+        target = (parent_1 && parent_1.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? parent_1.host : parent_1);
+    } while (
+    // portaled content
+    (!targetInLock && target !== document.body) ||
+        // self content
+        (targetInLock && (endTarget.contains(target) || endTarget === target)));
+    // handle epsilon around 0 (non standard zoom levels)
+    if (isDeltaPositive &&
+        ((noOverscroll && Math.abs(availableScroll) < 1) || (!noOverscroll && delta > availableScroll))) {
+        shouldCancelScroll = true;
+    }
+    else if (!isDeltaPositive &&
+        ((noOverscroll && Math.abs(availableScrollTop) < 1) || (!noOverscroll && -delta > availableScrollTop))) {
+        shouldCancelScroll = true;
+    }
+    return shouldCancelScroll;
+};
+exports.handleScroll = handleScroll;

package/node_modules/react-remove-scroll/dist/es5/index.d.ts

@@ -0,0 +1,2 @@
+import RemoveScroll from './Combination';
+export { RemoveScroll };

package/node_modules/react-remove-scroll/dist/es5/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveScroll = void 0;
+var tslib_1 = require("tslib");
+var Combination_1 = tslib_1.__importDefault(require("./Combination"));
+exports.RemoveScroll = Combination_1.default;

package/node_modules/react-remove-scroll/dist/es5/medium.d.ts

@@ -0,0 +1,2 @@
+import { IRemoveScrollEffectProps } from './types';
+export declare const effectCar: Readonly<import("use-sidecar/dist/es5/types").SideCarMedium<IRemoveScrollEffectProps>>;

package/node_modules/react-remove-scroll/dist/es5/medium.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectCar = void 0;
+var use_sidecar_1 = require("use-sidecar");
+exports.effectCar = (0, use_sidecar_1.createSidecarMedium)();

package/node_modules/react-remove-scroll/dist/es5/pinchAndZoom.d.ts

@@ -0,0 +1,8 @@
+import { Touch } from 'react';
+export declare const pinchOrZoom: (event: TouchEvent, cache: Record<number, Touch>) => false | {
+    action: string;
+    coords?: undefined;
+} | {
+    action: string;
+    coords: number[];
+};

package/node_modules/react-remove-scroll/dist/es5/pinchAndZoom.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pinchOrZoom = void 0;
+var ds = function (ab) { return (ab[0] <= 0 && ab[1] >= 0) || (ab[0] >= 0 && ab[1] <= 0); };
+var sign = function (x) { return (x < 0 ? -1 : 1); };
+var pinchOrZoom = function (event, cache) {
+    if (!event.changedTouches) {
+        return false;
+    }
+    if (event.touches.length === 2) {
+        var oldPoints = [cache[event.touches[0].identifier], cache[event.touches[1].identifier]];
+        var newPoints = [event.touches[0], event.touches[1]];
+        if (oldPoints[0] && oldPoints[1]) {
+            // Calculate the difference between the start and move coordinates
+            var diffx = [oldPoints[0].clientX - newPoints[0].clientX, oldPoints[1].clientX - newPoints[1].clientX];
+            var diffy = [oldPoints[0].clientY - newPoints[0].clientY, oldPoints[1].clientY - newPoints[1].clientY];
+            console.log(diffx, diffy);
+            if (ds(diffx) || ds(diffy)) {
+                return {
+                    action: 'zoom',
+                };
+            }
+            var mx = Math.max(Math.abs(diffx[0]), Math.abs(diffx[1]));
+            var my = Math.max(Math.abs(diffy[0]), Math.abs(diffy[1]));
+            return {
+                action: 'pinch',
+                coords: [mx * sign(diffx[0]), my * sign(diffx[1])],
+            };
+        }
+    }
+    Array.from(event.changedTouches).forEach(function (touch) { return (cache[touch.identifier] = touch); });
+    return {
+        action: 'move',
+        coords: [event.changedTouches[0].clientX, event.changedTouches[0].clientY],
+    };
+};
+exports.pinchOrZoom = pinchOrZoom;

package/node_modules/react-remove-scroll/dist/es5/sidecar.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("use-sidecar").SideCarComponent<import("./types").IRemoveScrollEffectProps>;
+export default _default;

package/node_modules/react-remove-scroll/dist/es5/sidecar.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var use_sidecar_1 = require("use-sidecar");
+var SideEffect_1 = require("./SideEffect");
+var medium_1 = require("./medium");
+exports.default = (0, use_sidecar_1.exportSidecar)(medium_1.effectCar, SideEffect_1.RemoveScrollSideCar);

package/node_modules/react-remove-scroll/dist/es5/types.d.ts

@@ -0,0 +1,104 @@
+import * as React from 'react';
+import { Ref, RefObject } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { RefAttributes } from 'react';
+export declare type Axis = 'v' | 'h';
+export declare type GapMode = 'padding' | 'margin';
+export interface RemoveScrollEffectCallbacks {
+    onScrollCapture(event: any): void;
+    onWheelCapture(event: any): void;
+    onTouchMoveCapture(event: any): void;
+}
+export interface ChildrenNode {
+    /**
+     * if forwardProps is false - children should be ReactNode
+     * and it would be wrapper with a div
+     * @see {@link IRemoveScrollSelfProps.as}
+     */
+    forwardProps?: false;
+    children: React.ReactNode;
+}
+export interface ChildrenForward {
+    /**
+     * if forwardProps is true - everything will be forwarded to a single child node
+     * otherwise - a Container, controlled by `as` prop will be rendered in place
+     * @default false
+     * @see {@link IRemoveScrollSelfProps.as}
+     */
+    forwardProps: true;
+    children: React.ReactElement;
+}
+export interface IRemoveScrollSelfProps {
+    ref?: Ref<HTMLElement>;
+    /**
+     * prevents 'position="relative"' being set on body
+     * @default false
+     */
+    noRelative?: boolean;
+    /**
+     * disables "event isolation" (suppressing of events happening outside of the Lock)
+     * @default false
+     */
+    noIsolation?: boolean;
+    /**
+     * enabled complete Lock isolation using `pointer-events:none` for anything outside the Lock
+     * you probably don't need it, except you do
+     * @default false
+     * @see {IRemoveScrollSelfProps.noIsolation}
+     */
+    inert?: boolean;
+    /**
+     * allows pinch-zoom, however might work not perfectly for normal scroll
+     */
+    allowPinchZoom?: boolean;
+    /**
+     * switches on/off the behavior of the component
+     */
+    enabled?: boolean;
+    /**
+     * Controls the body scroll bar removal
+     * @default false
+     */
+    removeScrollBar?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    /**
+     * array of refs to other Elements, which should be considered as a part of the Lock
+     */
+    shards?: Array<React.RefObject<any> | HTMLElement>;
+    /**
+     * Control host node used for the lock.
+     * @default 'div'
+     */
+    as?: string | React.ElementType;
+    /**
+     * controls the way "gap" is filled
+     * @default "margin"
+     */
+    gapMode?: GapMode;
+}
+export declare type IRemoveScrollProps = IRemoveScrollSelfProps & (ChildrenForward | ChildrenNode);
+export declare type IRemoveScrollUIProps = IRemoveScrollProps & {
+    sideCar: React.FC<any>;
+};
+export interface IRemoveScrollEffectProps {
+    noRelative?: boolean;
+    noIsolation?: boolean;
+    removeScrollBar?: boolean;
+    allowPinchZoom: boolean;
+    inert?: boolean;
+    shards?: Array<React.RefObject<any> | HTMLElement>;
+    lockRef: RefObject<HTMLElement>;
+    gapMode?: GapMode;
+    setCallbacks(cb: RemoveScrollEffectCallbacks): void;
+}
+interface WithClassNames {
+    classNames: {
+        fullWidth: string;
+        zeroRight: string;
+    };
+}
+declare type RefForwarded<T> = ForwardRefExoticComponent<T & RefAttributes<HTMLElement>> & WithClassNames;
+export declare type RemoveScrollType = RefForwarded<IRemoveScrollProps>;
+export declare type RemoveScrollUIType = RefForwarded<IRemoveScrollUIProps>;
+export {};

package/node_modules/react-remove-scroll/dist/es5/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/react-remove-scroll/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "react-remove-scroll",
+  "version": "2.7.2",
+  "description": "Disables scroll outside of `children` node.",
+  "main": "dist/es5/index.js",
+  "jsnext:main": "dist/es2015/index.js",
+  "module": "dist/es2015/index.js",
+  "types": "dist/es5/index.d.ts",
+  "module:es2019": "dist/es2019/index.js",
+  "scripts": {
+    "dev": "lib-builder dev",
+    "test": "jest",
+    "test:ci": "jest --runInBand --coverage",
+    "build": "lib-builder build && yarn size:report",
+    "release": "yarn build && yarn test",
+    "size": "size-limit",
+    "size:report": "size-limit --json > .size.json",
+    "lint": "lib-builder lint",
+    "format": "lib-builder format",
+    "update": "lib-builder update",
+    "prepublish": "yarn build && yarn changelog",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+    "changelog:rewrite": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "storybook": "start-storybook -p 6006"
+  },
+  "keywords": [
+    "scroll"
+  ],
+  "author": "Anton Korzunov <thekashey@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@babel/core": "^7.17.9",
+    "@size-limit/preset-small-lib": "^11.0.2",
+    "size-limit": "^11.0.2",
+    "@storybook/react": "^6.4.22",
+    "@theuiteam/lib-builder": "^0.1.4",
+    "@types/enzyme-adapter-react-16": "^1.0.6",
+    "babel-loader": "^8.2.4",
+    "enzyme-adapter-react-16": "^1.15.6"
+  },
+  "resolutions": {
+    "@types/react": "^18.0.0",
+    "tslib": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "UI",
+    "sidecar"
+  ],
+  "repository": "https://github.com/theKashey/react-remove-scroll",
+  "dependencies": {
+    "react-remove-scroll-bar": "^2.3.7",
+    "react-style-singleton": "^2.2.3",
+    "tslib": "^2.1.0",
+    "use-callback-ref": "^1.3.3",
+    "use-sidecar": "^1.1.3"
+  },
+  "sideEffects": [
+    "**/sidecar.js"
+  ],
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "prettier --write",
+      "eslint --fix",
+      "git add"
+    ],
+    "*.{js,css,json,md}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "prettier": {
+    "printWidth": 120,
+    "trailingComma": "es5",
+    "tabWidth": 2,
+    "semi": true,
+    "singleQuote": true
+  },
+  "packageManager": "yarn@1.22.19"
+}

package/node_modules/react-remove-scroll/sidecar/package.json

@@ -0,0 +1,7 @@
+{
+  "private": true,
+  "main": "../dist/es5/sidecar.js",
+  "jsnext:main": "../dist/es2015/sidecar.js",
+  "module": "../dist/es2015/sidecar.js",
+  "types": "sidecar.d.ts"
+}