@nulogy/components 16.1.0 → 17.0.0

package/dist/esm/node_modules/.pnpm/framer-motion@12.35.0_@emotion_is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js

@@ -0,0 +1,427 @@
+import { addPointerEvent } from "../../events/add-pointer-event.js";
+import { extractEventInfo } from "../../events/event-info.js";
+import { getContextWindow } from "../../utils/get-context-window.js";
+import { isRefObject } from "../../utils/is-ref-object.js";
+import { PanSession } from "../pan/PanSession.js";
+import { applyConstraints, calcRelativeConstraints, resolveDragElastic, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, calcOrigin } from "./utils/constraints.js";
+import { createBox } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/projection/geometry/models.js";
+import { frame } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/frameloop/frame.js";
+import { eachAxis } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/projection/utils/each-axis.js";
+import { measurePageBox } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/projection/utils/measure.js";
+import { convertBoxToBoundingBox, convertBoundingBoxToBox } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/projection/geometry/conversion.js";
+import { addValueToWillChange } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/value/will-change/add-will-change.js";
+import { animateMotionValue } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.js";
+import { addDomEvent } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/events/add-dom-event.js";
+import { setDragLock } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/gestures/drag/state/set-active.js";
+import { resize } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/resize/index.js";
+import { percent } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/value/types/numbers/units.js";
+import { calcLength } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/projection/geometry/delta-calc.js";
+import { mixNumber } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/utils/mix/number.js";
+import { isElementTextInput } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.js";
+const elementDragControls = /* @__PURE__ */ new WeakMap();
+class VisualElementDragControls {
+  constructor(visualElement) {
+    this.openDragLock = null;
+    this.isDragging = false;
+    this.currentDirection = null;
+    this.originPoint = { x: 0, y: 0 };
+    this.constraints = false;
+    this.hasMutatedConstraints = false;
+    this.elastic = createBox();
+    this.latestPointerEvent = null;
+    this.latestPanInfo = null;
+    this.visualElement = visualElement;
+  }
+  start(originEvent, { snapToCursor = false, distanceThreshold } = {}) {
+    const { presenceContext } = this.visualElement;
+    if (presenceContext && presenceContext.isPresent === false)
+      return;
+    const onSessionStart = (event) => {
+      if (snapToCursor) {
+        this.snapToCursor(extractEventInfo(event).point);
+      }
+      this.stopAnimation();
+    };
+    const onStart = (event, info) => {
+      const { drag, dragPropagation, onDragStart } = this.getProps();
+      if (drag && !dragPropagation) {
+        if (this.openDragLock)
+          this.openDragLock();
+        this.openDragLock = setDragLock(drag);
+        if (!this.openDragLock)
+          return;
+      }
+      this.latestPointerEvent = event;
+      this.latestPanInfo = info;
+      this.isDragging = true;
+      this.currentDirection = null;
+      this.resolveConstraints();
+      if (this.visualElement.projection) {
+        this.visualElement.projection.isAnimationBlocked = true;
+        this.visualElement.projection.target = void 0;
+      }
+      eachAxis((axis) => {
+        let current = this.getAxisMotionValue(axis).get() || 0;
+        if (percent.test(current)) {
+          const { projection } = this.visualElement;
+          if (projection && projection.layout) {
+            const measuredAxis = projection.layout.layoutBox[axis];
+            if (measuredAxis) {
+              const length = calcLength(measuredAxis);
+              current = length * (parseFloat(current) / 100);
+            }
+          }
+        }
+        this.originPoint[axis] = current;
+      });
+      if (onDragStart) {
+        frame.update(() => onDragStart(event, info), false, true);
+      }
+      addValueToWillChange(this.visualElement, "transform");
+      const { animationState } = this.visualElement;
+      animationState && animationState.setActive("whileDrag", true);
+    };
+    const onMove = (event, info) => {
+      this.latestPointerEvent = event;
+      this.latestPanInfo = info;
+      const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag } = this.getProps();
+      if (!dragPropagation && !this.openDragLock)
+        return;
+      const { offset } = info;
+      if (dragDirectionLock && this.currentDirection === null) {
+        this.currentDirection = getCurrentDirection(offset);
+        if (this.currentDirection !== null) {
+          onDirectionLock && onDirectionLock(this.currentDirection);
+        }
+        return;
+      }
+      this.updateAxis("x", info.point, offset);
+      this.updateAxis("y", info.point, offset);
+      this.visualElement.render();
+      if (onDrag) {
+        frame.update(() => onDrag(event, info), false, true);
+      }
+    };
+    const onSessionEnd = (event, info) => {
+      this.latestPointerEvent = event;
+      this.latestPanInfo = info;
+      this.stop(event, info);
+      this.latestPointerEvent = null;
+      this.latestPanInfo = null;
+    };
+    const resumeAnimation = () => {
+      const { dragSnapToOrigin: snap } = this.getProps();
+      if (snap || this.constraints) {
+        this.startAnimation({ x: 0, y: 0 });
+      }
+    };
+    const { dragSnapToOrigin } = this.getProps();
+    this.panSession = new PanSession(originEvent, {
+      onSessionStart,
+      onStart,
+      onMove,
+      onSessionEnd,
+      resumeAnimation
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin,
+      distanceThreshold,
+      contextWindow: getContextWindow(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+   * @internal
+   */
+  stop(event, panInfo) {
+    const finalEvent = event || this.latestPointerEvent;
+    const finalPanInfo = panInfo || this.latestPanInfo;
+    const isDragging = this.isDragging;
+    this.cancel();
+    if (!isDragging || !finalPanInfo || !finalEvent)
+      return;
+    const { velocity } = finalPanInfo;
+    this.startAnimation(velocity);
+    const { onDragEnd } = this.getProps();
+    if (onDragEnd) {
+      frame.postRender(() => onDragEnd(finalEvent, finalPanInfo));
+    }
+  }
+  /**
+   * @internal
+   */
+  cancel() {
+    this.isDragging = false;
+    const { projection, animationState } = this.visualElement;
+    if (projection) {
+      projection.isAnimationBlocked = false;
+    }
+    this.endPanSession();
+    const { dragPropagation } = this.getProps();
+    if (!dragPropagation && this.openDragLock) {
+      this.openDragLock();
+      this.openDragLock = null;
+    }
+    animationState && animationState.setActive("whileDrag", false);
+  }
+  /**
+   * Clean up the pan session without modifying other drag state.
+   * This is used during unmount to ensure event listeners are removed
+   * without affecting projection animations or drag locks.
+   * @internal
+   */
+  endPanSession() {
+    this.panSession && this.panSession.end();
+    this.panSession = void 0;
+  }
+  updateAxis(axis, _point, offset) {
+    const { drag } = this.getProps();
+    if (!offset || !shouldDrag(axis, drag, this.currentDirection))
+      return;
+    const axisValue = this.getAxisMotionValue(axis);
+    let next = this.originPoint[axis] + offset[axis];
+    if (this.constraints && this.constraints[axis]) {
+      next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);
+    }
+    axisValue.set(next);
+  }
+  resolveConstraints() {
+    const { dragConstraints, dragElastic } = this.getProps();
+    const layout = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(false) : this.visualElement.projection?.layout;
+    const prevConstraints = this.constraints;
+    if (dragConstraints && isRefObject(dragConstraints)) {
+      if (!this.constraints) {
+        this.constraints = this.resolveRefConstraints();
+      }
+    } else {
+      if (dragConstraints && layout) {
+        this.constraints = calcRelativeConstraints(layout.layoutBox, dragConstraints);
+      } else {
+        this.constraints = false;
+      }
+    }
+    this.elastic = resolveDragElastic(dragElastic);
+    if (prevConstraints !== this.constraints && !isRefObject(dragConstraints) && layout && this.constraints && !this.hasMutatedConstraints) {
+      eachAxis((axis) => {
+        if (this.constraints !== false && this.getAxisMotionValue(axis)) {
+          this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);
+        }
+      });
+    }
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();
+    if (!constraints || !isRefObject(constraints))
+      return false;
+    const constraintsElement = constraints.current;
+    const { projection } = this.visualElement;
+    if (!projection || !projection.layout)
+      return false;
+    const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());
+    let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);
+    if (onMeasureDragConstraints) {
+      const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));
+      this.hasMutatedConstraints = !!userConstraints;
+      if (userConstraints) {
+        measuredConstraints = convertBoundingBoxToBox(userConstraints);
+      }
+    }
+    return measuredConstraints;
+  }
+  startAnimation(velocity) {
+    const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd } = this.getProps();
+    const constraints = this.constraints || {};
+    const momentumAnimations = eachAxis((axis) => {
+      if (!shouldDrag(axis, drag, this.currentDirection)) {
+        return;
+      }
+      let transition = constraints && constraints[axis] || {};
+      if (dragSnapToOrigin)
+        transition = { min: 0, max: 0 };
+      const bounceStiffness = dragElastic ? 200 : 1e6;
+      const bounceDamping = dragElastic ? 40 : 1e7;
+      const inertia = {
+        type: "inertia",
+        velocity: dragMomentum ? velocity[axis] : 0,
+        bounceStiffness,
+        bounceDamping,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...dragTransition,
+        ...transition
+      };
+      return this.startAxisValueAnimation(axis, inertia);
+    });
+    return Promise.all(momentumAnimations).then(onDragTransitionEnd);
+  }
+  startAxisValueAnimation(axis, transition) {
+    const axisValue = this.getAxisMotionValue(axis);
+    addValueToWillChange(this.visualElement, axis);
+    return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false));
+  }
+  stopAnimation() {
+    eachAxis((axis) => this.getAxisMotionValue(axis).stop());
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(axis) {
+    const dragKey = `_drag${axis.toUpperCase()}`;
+    const props = this.visualElement.getProps();
+    const externalMotionValue = props[dragKey];
+    return externalMotionValue ? externalMotionValue : this.visualElement.getValue(axis, (props.initial ? props.initial[axis] : void 0) || 0);
+  }
+  snapToCursor(point) {
+    eachAxis((axis) => {
+      const { drag } = this.getProps();
+      if (!shouldDrag(axis, drag, this.currentDirection))
+        return;
+      const { projection } = this.visualElement;
+      const axisValue = this.getAxisMotionValue(axis);
+      if (projection && projection.layout) {
+        const { min, max } = projection.layout.layoutBox[axis];
+        const current = axisValue.get() || 0;
+        axisValue.set(point[axis] - mixNumber(min, max, 0.5) + current);
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag, dragConstraints } = this.getProps();
+    const { projection } = this.visualElement;
+    if (!isRefObject(dragConstraints) || !projection || !this.constraints)
+      return;
+    this.stopAnimation();
+    const boxProgress = { x: 0, y: 0 };
+    eachAxis((axis) => {
+      const axisValue = this.getAxisMotionValue(axis);
+      if (axisValue && this.constraints !== false) {
+        const latest = axisValue.get();
+        boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);
+      }
+    });
+    const { transformTemplate } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = transformTemplate ? transformTemplate({}, "") : "none";
+    projection.root && projection.root.updateScroll();
+    projection.updateLayout();
+    this.constraints = false;
+    this.resolveConstraints();
+    eachAxis((axis) => {
+      if (!shouldDrag(axis, drag, null))
+        return;
+      const axisValue = this.getAxisMotionValue(axis);
+      const { min, max } = this.constraints[axis];
+      axisValue.set(mixNumber(min, max, boxProgress[axis]));
+    });
+    this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    elementDragControls.set(this.visualElement, this);
+    const element = this.visualElement.current;
+    const stopPointerListener = addPointerEvent(element, "pointerdown", (event) => {
+      const { drag, dragListener = true } = this.getProps();
+      const target = event.target;
+      const isClickingTextInputChild = target !== element && isElementTextInput(target);
+      if (drag && dragListener && !isClickingTextInputChild) {
+        this.start(event);
+      }
+    });
+    let stopResizeObservers;
+    const measureDragConstraints = () => {
+      const { dragConstraints } = this.getProps();
+      if (isRefObject(dragConstraints) && dragConstraints.current) {
+        this.constraints = this.resolveRefConstraints();
+        if (!stopResizeObservers) {
+          stopResizeObservers = startResizeObservers(element, dragConstraints.current, () => this.scalePositionWithinConstraints());
+        }
+      }
+    };
+    const { projection } = this.visualElement;
+    const stopMeasureLayoutListener = projection.addEventListener("measure", measureDragConstraints);
+    if (projection && !projection.layout) {
+      projection.root && projection.root.updateScroll();
+      projection.updateLayout();
+    }
+    frame.read(measureDragConstraints);
+    const stopResizeListener = addDomEvent(window, "resize", () => this.scalePositionWithinConstraints());
+    const stopLayoutUpdateListener = projection.addEventListener("didUpdate", (({ delta, hasLayoutChanged }) => {
+      if (this.isDragging && hasLayoutChanged) {
+        eachAxis((axis) => {
+          const motionValue = this.getAxisMotionValue(axis);
+          if (!motionValue)
+            return;
+          this.originPoint[axis] += delta[axis].translate;
+          motionValue.set(motionValue.get() + delta[axis].translate);
+        });
+        this.visualElement.render();
+      }
+    }));
+    return () => {
+      stopResizeListener();
+      stopPointerListener();
+      stopMeasureLayoutListener();
+      stopLayoutUpdateListener && stopLayoutUpdateListener();
+      stopResizeObservers && stopResizeObservers();
+    };
+  }
+  getProps() {
+    const props = this.visualElement.getProps();
+    const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true } = props;
+    return {
+      ...props,
+      drag,
+      dragDirectionLock,
+      dragPropagation,
+      dragConstraints,
+      dragElastic,
+      dragMomentum
+    };
+  }
+}
+function skipFirstCall(callback) {
+  let isFirst = true;
+  return () => {
+    if (isFirst) {
+      isFirst = false;
+      return;
+    }
+    callback();
+  };
+}
+function startResizeObservers(element, constraintsElement, onResize) {
+  const stopElement = resize(element, skipFirstCall(onResize));
+  const stopContainer = resize(constraintsElement, skipFirstCall(onResize));
+  return () => {
+    stopElement();
+    stopContainer();
+  };
+}
+function shouldDrag(direction, drag, currentDirection) {
+  return (drag === true || drag === direction) && (currentDirection === null || currentDirection === direction);
+}
+function getCurrentDirection(offset, lockThreshold = 10) {
+  let direction = null;
+  if (Math.abs(offset.y) > lockThreshold) {
+    direction = "y";
+  } else if (Math.abs(offset.x) > lockThreshold) {
+    direction = "x";
+  }
+  return direction;
+}
+export {
+  VisualElementDragControls,
+  elementDragControls
+};
+//# sourceMappingURL=VisualElementDragControls.js.map

package/dist/esm/node_modules/.pnpm/framer-motion@12.35.0_@emotion_is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VisualElementDragControls.js","sources":["../../../../../../../../../../../node_modules/.pnpm/framer-motion@12.35.0_@emotion+is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs"],"sourcesContent":["import { createBox, frame, eachAxis, measurePageBox, convertBoxToBoundingBox, convertBoundingBoxToBox, addValueToWillChange, animateMotionValue, mixNumber, addDomEvent, setDragLock, percent, calcLength, resize, isElementTextInput } from 'motion-dom';\nimport { invariant } from 'motion-utils';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { PanSession } from '../pan/PanSession.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\n\nconst elementDragControls = new WeakMap();\nclass VisualElementDragControls {\n    constructor(visualElement) {\n        this.openDragLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        /**\n         * The latest pointer event. Used as fallback when the `cancel` and `stop` functions are called without arguments.\n         */\n        this.latestPointerEvent = null;\n        /**\n         * The latest pan info. Used as fallback when the `cancel` and `stop` functions are called without arguments.\n         */\n        this.latestPanInfo = null;\n        this.visualElement = visualElement;\n    }\n    start(originEvent, { snapToCursor = false, distanceThreshold } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.isPresent === false)\n            return;\n        const onSessionStart = (event) => {\n            if (snapToCursor) {\n                this.snapToCursor(extractEventInfo(event).point);\n            }\n            this.stopAnimation();\n        };\n        const onStart = (event, info) => {\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\n            if (drag && !dragPropagation) {\n                if (this.openDragLock)\n                    this.openDragLock();\n                this.openDragLock = setDragLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!this.openDragLock)\n                    return;\n            }\n            this.latestPointerEvent = event;\n            this.latestPanInfo = info;\n            this.isDragging = true;\n            this.currentDirection = null;\n            this.resolveConstraints();\n            if (this.visualElement.projection) {\n                this.visualElement.projection.isAnimationBlocked = true;\n                this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin and pointer offset\n             */\n            eachAxis((axis) => {\n                let current = this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    const { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            if (onDragStart) {\n                frame.update(() => onDragStart(event, info), false, true);\n            }\n            addValueToWillChange(this.visualElement, \"transform\");\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", true);\n        };\n        const onMove = (event, info) => {\n            this.latestPointerEvent = event;\n            this.latestPanInfo = info;\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openDragLock)\n                return;\n            const { offset } = info;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && this.currentDirection === null) {\n                this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (this.currentDirection !== null) {\n                    onDirectionLock && onDirectionLock(this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            this.updateAxis(\"x\", info.point, offset);\n            this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            this.visualElement.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            if (onDrag) {\n                frame.update(() => onDrag(event, info), false, true);\n            }\n        };\n        const onSessionEnd = (event, info) => {\n            this.latestPointerEvent = event;\n            this.latestPanInfo = info;\n            this.stop(event, info);\n            this.latestPointerEvent = null;\n            this.latestPanInfo = null;\n        };\n        const resumeAnimation = () => {\n            const { dragSnapToOrigin: snap } = this.getProps();\n            if (snap || this.constraints) {\n                this.startAnimation({ x: 0, y: 0 });\n            }\n        };\n        const { dragSnapToOrigin } = this.getProps();\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n            resumeAnimation,\n        }, {\n            transformPagePoint: this.visualElement.getTransformPagePoint(),\n            dragSnapToOrigin,\n            distanceThreshold,\n            contextWindow: getContextWindow(this.visualElement),\n            element: this.visualElement.current,\n        });\n    }\n    /**\n     * @internal\n     */\n    stop(event, panInfo) {\n        const finalEvent = event || this.latestPointerEvent;\n        const finalPanInfo = panInfo || this.latestPanInfo;\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging || !finalPanInfo || !finalEvent)\n            return;\n        const { velocity } = finalPanInfo;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        if (onDragEnd) {\n            frame.postRender(() => onDragEnd(finalEvent, finalPanInfo));\n        }\n    }\n    /**\n     * @internal\n     */\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.endPanSession();\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openDragLock) {\n            this.openDragLock();\n            this.openDragLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", false);\n    }\n    /**\n     * Clean up the pan session without modifying other drag state.\n     * This is used during unmount to ensure event listeners are removed\n     * without affecting projection animations or drag locks.\n     * @internal\n     */\n    endPanSession() {\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    }\n    resolveConstraints() {\n        const { dragConstraints, dragElastic } = this.getProps();\n        const layout = this.visualElement.projection &&\n            !this.visualElement.projection.layout\n            ? this.visualElement.projection.measure(false)\n            : this.visualElement.projection?.layout;\n        const prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.layoutBox, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative. This only applies to relative (non-ref)\n         * constraints, as ref-based constraints from calcViewportConstraints are already in the\n         * correct coordinate space for the motion value transform offset.\n         */\n        if (prevConstraints !== this.constraints &&\n            !isRefObject(dragConstraints) &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis((axis) => {\n                if (this.constraints !== false &&\n                    this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\", \"drag-constraints-ref\");\n        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints && constraints[axis]) || {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    }\n    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        addValueToWillChange(this.visualElement, axis);\n        return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false));\n    }\n    stopAnimation() {\n        eachAxis((axis) => this.getAxisMotionValue(axis).stop());\n    }\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    getAxisMotionValue(axis) {\n        const dragKey = `_drag${axis.toUpperCase()}`;\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial\n                ? props.initial[axis]\n                : undefined) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                /**\n                 * The layout measurement includes the current transform value,\n                 * so we need to add it back to get the correct snap position.\n                 * This fixes an issue where elements with initial coordinates\n                 * would snap to the wrong position on the first drag.\n                 */\n                const current = axisValue.get() || 0;\n                axisValue.set(point[axis] - mixNumber(min, max, 0.5) + current);\n            }\n        });\n    }\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    scalePositionWithinConstraints() {\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue && this.constraints !== false) {\n                const latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        projection.root && projection.root.updateScroll();\n        projection.updateLayout();\n        /**\n         * Reset constraints so resolveConstraints() will recalculate them\n         * with the freshly measured layout rather than returning the cached value.\n         */\n        this.constraints = false;\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mixNumber(min, max, boxProgress[axis]));\n        });\n        /**\n         * Flush the updated transform to the DOM synchronously to prevent\n         * a visual flash at the element's CSS layout position (0,0) when\n         * the transform was stripped for measurement.\n         */\n        this.visualElement.render();\n    }\n    addListeners() {\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            const target = event.target;\n            /**\n             * Only block drag if clicking on a text input child element\n             * (input, textarea, select, contenteditable) where users might\n             * want to select text or interact with the control.\n             *\n             * Buttons and links don't block drag since they don't have\n             * click-and-move actions of their own.\n             */\n            const isClickingTextInputChild = target !== element && isElementTextInput(target);\n            if (drag && dragListener && !isClickingTextInputChild) {\n                this.start(event);\n            }\n        });\n        /**\n         * If using ref-based constraints, observe both the draggable element\n         * and the constraint container for size changes via ResizeObserver.\n         * Setup is deferred because dragConstraints.current is null when\n         * addListeners first runs (React hasn't committed the ref yet).\n         */\n        let stopResizeObservers;\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints) && dragConstraints.current) {\n                this.constraints = this.resolveRefConstraints();\n                if (!stopResizeObservers) {\n                    stopResizeObservers = startResizeObservers(element, dragConstraints.current, () => this.scalePositionWithinConstraints());\n                }\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            projection.root && projection.root.updateScroll();\n            projection.updateLayout();\n        }\n        frame.read(measureDragConstraints);\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const motionValue = this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                this.visualElement.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener && stopLayoutUpdateListener();\n            stopResizeObservers && stopResizeObservers();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\n}\nfunction skipFirstCall(callback) {\n    let isFirst = true;\n    return () => {\n        if (isFirst) {\n            isFirst = false;\n            return;\n        }\n        callback();\n    };\n}\nfunction startResizeObservers(element, constraintsElement, onResize) {\n    const stopElement = resize(element, skipFirstCall(onResize));\n    const stopContainer = resize(constraintsElement, skipFirstCall(onResize));\n    return () => {\n        stopElement();\n        stopContainer();\n    };\n}\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold = 10) {\n    let direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n//# sourceMappingURL=VisualElementDragControls.mjs.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/framer-motion@12.35.0_@emotion_is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/index.js

@@ -0,0 +1,39 @@
+import { VisualElementDragControls } from "./VisualElementDragControls.js";
+import { Feature } from "../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/Feature.js";
+import { noop } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/noop.js";
+class DragGesture extends Feature {
+  constructor(node) {
+    super(node);
+    this.removeGroupControls = noop;
+    this.removeListeners = noop;
+    this.controls = new VisualElementDragControls(node);
+  }
+  mount() {
+    const { dragControls } = this.node.getProps();
+    if (dragControls) {
+      this.removeGroupControls = dragControls.subscribe(this.controls);
+    }
+    this.removeListeners = this.controls.addListeners() || noop;
+  }
+  update() {
+    const { dragControls } = this.node.getProps();
+    const { dragControls: prevDragControls } = this.node.prevProps || {};
+    if (dragControls !== prevDragControls) {
+      this.removeGroupControls();
+      if (dragControls) {
+        this.removeGroupControls = dragControls.subscribe(this.controls);
+      }
+    }
+  }
+  unmount() {
+    this.removeGroupControls();
+    this.removeListeners();
+    if (!this.controls.isDragging) {
+      this.controls.endPanSession();
+    }
+  }
+}
+export {
+  DragGesture
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/.pnpm/framer-motion@12.35.0_@emotion_is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../../node_modules/.pnpm/framer-motion@12.35.0_@emotion+is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/index.mjs"],"sourcesContent":["import { Feature } from 'motion-dom';\nimport { noop } from 'motion-utils';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\n\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = noop;\n        this.removeListeners = noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || noop;\n    }\n    update() {\n        const { dragControls } = this.node.getProps();\n        const { dragControls: prevDragControls } = this.node.prevProps || {};\n        if (dragControls !== prevDragControls) {\n            this.removeGroupControls();\n            if (dragControls) {\n                this.removeGroupControls = dragControls.subscribe(this.controls);\n            }\n        }\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n        /**\n         * In React 19, during list reorder reconciliation, components may\n         * briefly unmount and remount while the drag is still active. If we're\n         * actively dragging, we should NOT end the pan session - it will\n         * continue tracking pointer events via its window-level listeners.\n         *\n         * The pan session will be properly cleaned up when:\n         * 1. The drag ends naturally (pointerup/pointercancel)\n         * 2. The component is truly removed from the DOM\n         */\n        if (!this.controls.isDragging) {\n            this.controls.endPanSession();\n        }\n    }\n}\n\nexport { DragGesture };\n//# sourceMappingURL=index.mjs.map\n"],"names":[],"mappings":";;;AAIA,MAAM,oBAAoB,QAAQ;AAAA,EAC9B,YAAY,MAAM;AACd,UAAM,IAAI;AACV,SAAK,sBAAsB;AAC3B,SAAK,kBAAkB;AACvB,SAAK,WAAW,IAAI,0BAA0B,IAAI;AAAA,EACtD;AAAA,EACA,QAAQ;AAGJ,UAAM,EAAE,aAAY,IAAK,KAAK,KAAK,SAAQ;AAC3C,QAAI,cAAc;AACd,WAAK,sBAAsB,aAAa,UAAU,KAAK,QAAQ;AAAA,IACnE;AACA,SAAK,kBAAkB,KAAK,SAAS,aAAY,KAAM;AAAA,EAC3D;AAAA,EACA,SAAS;AACL,UAAM,EAAE,aAAY,IAAK,KAAK,KAAK,SAAQ;AAC3C,UAAM,EAAE,cAAc,iBAAgB,IAAK,KAAK,KAAK,aAAa,CAAA;AAClE,QAAI,iBAAiB,kBAAkB;AACnC,WAAK,oBAAmB;AACxB,UAAI,cAAc;AACd,aAAK,sBAAsB,aAAa,UAAU,KAAK,QAAQ;AAAA,MACnE;AAAA,IACJ;AAAA,EACJ;AAAA,EACA,UAAU;AACN,SAAK,oBAAmB;AACxB,SAAK,gBAAe;AAWpB,QAAI,CAAC,KAAK,SAAS,YAAY;AAC3B,WAAK,SAAS,cAAa;AAAA,IAC/B;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/framer-motion@12.35.0_@emotion_is-prop-valid@1.4.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js

@@ -0,0 +1,94 @@
+import { mixNumber } from "../../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/utils/mix/number.js";
+import { calcLength } from "../../../../../../../../motion-dom@12.35.0/node_modules/motion-dom/dist/es/projection/geometry/delta-calc.js";
+import { progress } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/progress.js";
+import { clamp } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.js";
+function applyConstraints(point, { min, max }, elastic) {
+  if (min !== void 0 && point < min) {
+    point = elastic ? mixNumber(min, point, elastic.min) : Math.max(point, min);
+  } else if (max !== void 0 && point > max) {
+    point = elastic ? mixNumber(max, point, elastic.max) : Math.min(point, max);
+  }
+  return point;
+}
+function calcRelativeAxisConstraints(axis, min, max) {
+  return {
+    min: min !== void 0 ? axis.min + min : void 0,
+    max: max !== void 0 ? axis.max + max - (axis.max - axis.min) : void 0
+  };
+}
+function calcRelativeConstraints(layoutBox, { top, left, bottom, right }) {
+  return {
+    x: calcRelativeAxisConstraints(layoutBox.x, left, right),
+    y: calcRelativeAxisConstraints(layoutBox.y, top, bottom)
+  };
+}
+function calcViewportAxisConstraints(layoutAxis, constraintsAxis) {
+  let min = constraintsAxis.min - layoutAxis.min;
+  let max = constraintsAxis.max - layoutAxis.max;
+  if (constraintsAxis.max - constraintsAxis.min < layoutAxis.max - layoutAxis.min) {
+    [min, max] = [max, min];
+  }
+  return { min, max };
+}
+function calcViewportConstraints(layoutBox, constraintsBox) {
+  return {
+    x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),
+    y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y)
+  };
+}
+function calcOrigin(source, target) {
+  let origin = 0.5;
+  const sourceLength = calcLength(source);
+  const targetLength = calcLength(target);
+  if (targetLength > sourceLength) {
+    origin = progress(target.min, target.max - sourceLength, source.min);
+  } else if (sourceLength > targetLength) {
+    origin = progress(source.min, source.max - targetLength, target.min);
+  }
+  return clamp(0, 1, origin);
+}
+function rebaseAxisConstraints(layout, constraints) {
+  const relativeConstraints = {};
+  if (constraints.min !== void 0) {
+    relativeConstraints.min = constraints.min - layout.min;
+  }
+  if (constraints.max !== void 0) {
+    relativeConstraints.max = constraints.max - layout.min;
+  }
+  return relativeConstraints;
+}
+const defaultElastic = 0.35;
+function resolveDragElastic(dragElastic = defaultElastic) {
+  if (dragElastic === false) {
+    dragElastic = 0;
+  } else if (dragElastic === true) {
+    dragElastic = defaultElastic;
+  }
+  return {
+    x: resolveAxisElastic(dragElastic, "left", "right"),
+    y: resolveAxisElastic(dragElastic, "top", "bottom")
+  };
+}
+function resolveAxisElastic(dragElastic, minLabel, maxLabel) {
+  return {
+    min: resolvePointElastic(dragElastic, minLabel),
+    max: resolvePointElastic(dragElastic, maxLabel)
+  };
+}
+function resolvePointElastic(dragElastic, label) {
+  return typeof dragElastic === "number" ? dragElastic : dragElastic[label] || 0;
+}
+export {
+  applyConstraints,
+  calcOrigin,
+  calcRelativeAxisConstraints,
+  calcRelativeConstraints,
+  calcViewportAxisConstraints,
+  calcViewportConstraints,
+  defaultElastic,
+  rebaseAxisConstraints,
+  resolveAxisElastic,
+  resolveDragElastic,
+  resolvePointElastic
+};
+//# sourceMappingURL=constraints.js.map