@embedpdf/utils 1.4.1 → 2.0.0-next.0

package/dist/svelte/index.js

@@ -0,0 +1,757 @@
+import * as $ from "svelte/internal/client";
+import "svelte/internal/disclose-version";
+import { getCounterRotation } from "@embedpdf/utils";
+class DragResizeController {
+  constructor(config, onUpdate) {
+    this.config = config;
+    this.onUpdate = onUpdate;
+    this.state = "idle";
+    this.startPoint = null;
+    this.startElement = null;
+    this.activeHandle = null;
+    this.currentPosition = null;
+    this.activeVertexIndex = null;
+    this.startVertices = [];
+    this.currentVertices = [];
+    this.currentVertices = config.vertices || [];
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    this.currentVertices = config.vertices || [];
+  }
+  startDrag(clientX, clientY) {
+    this.state = "dragging";
+    this.startPoint = { x: clientX, y: clientY };
+    this.startElement = { ...this.config.element };
+    this.currentPosition = { ...this.config.element };
+    this.onUpdate({
+      state: "start",
+      transformData: {
+        type: "move",
+        changes: {
+          rect: this.startElement
+        }
+      }
+    });
+  }
+  startResize(handle, clientX, clientY) {
+    this.state = "resizing";
+    this.activeHandle = handle;
+    this.startPoint = { x: clientX, y: clientY };
+    this.startElement = { ...this.config.element };
+    this.currentPosition = { ...this.config.element };
+    this.onUpdate({
+      state: "start",
+      transformData: {
+        type: "resize",
+        changes: {
+          rect: this.startElement
+        },
+        metadata: {
+          handle: this.activeHandle,
+          maintainAspectRatio: this.config.maintainAspectRatio
+        }
+      }
+    });
+  }
+  startVertexEdit(vertexIndex, clientX, clientY) {
+    this.currentVertices = [...this.config.vertices ?? this.currentVertices];
+    if (vertexIndex < 0 || vertexIndex >= this.currentVertices.length) return;
+    this.state = "vertex-editing";
+    this.activeVertexIndex = vertexIndex;
+    this.startPoint = { x: clientX, y: clientY };
+    this.startVertices = [...this.currentVertices];
+    this.onUpdate({
+      state: "start",
+      transformData: {
+        type: "vertex-edit",
+        changes: {
+          vertices: this.startVertices
+        },
+        metadata: {
+          vertexIndex
+        }
+      }
+    });
+  }
+  move(clientX, clientY) {
+    if (this.state === "idle" || !this.startPoint) return;
+    if (this.state === "dragging" && this.startElement) {
+      const delta = this.calculateDelta(clientX, clientY);
+      const position = this.calculateDragPosition(delta);
+      this.currentPosition = position;
+      this.onUpdate({
+        state: "move",
+        transformData: {
+          type: "move",
+          changes: {
+            rect: position
+          }
+        }
+      });
+    } else if (this.state === "resizing" && this.activeHandle && this.startElement) {
+      const delta = this.calculateDelta(clientX, clientY);
+      const position = this.calculateResizePosition(delta, this.activeHandle);
+      this.currentPosition = position;
+      this.onUpdate({
+        state: "move",
+        transformData: {
+          type: "resize",
+          changes: {
+            rect: position
+          },
+          metadata: {
+            handle: this.activeHandle,
+            maintainAspectRatio: this.config.maintainAspectRatio
+          }
+        }
+      });
+    } else if (this.state === "vertex-editing" && this.activeVertexIndex !== null) {
+      const vertices = this.calculateVertexPosition(clientX, clientY);
+      this.currentVertices = vertices;
+      this.onUpdate({
+        state: "move",
+        transformData: {
+          type: "vertex-edit",
+          changes: {
+            vertices
+          },
+          metadata: {
+            vertexIndex: this.activeVertexIndex
+          }
+        }
+      });
+    }
+  }
+  end() {
+    if (this.state === "idle") return;
+    const wasState = this.state;
+    const handle = this.activeHandle;
+    const vertexIndex = this.activeVertexIndex;
+    if (wasState === "vertex-editing") {
+      this.onUpdate({
+        state: "end",
+        transformData: {
+          type: "vertex-edit",
+          changes: {
+            vertices: this.currentVertices
+          },
+          metadata: {
+            vertexIndex: vertexIndex || void 0
+          }
+        }
+      });
+    } else {
+      const finalPosition = this.getCurrentPosition();
+      this.onUpdate({
+        state: "end",
+        transformData: {
+          type: wasState === "dragging" ? "move" : "resize",
+          changes: {
+            rect: finalPosition
+          },
+          metadata: wasState === "dragging" ? void 0 : {
+            handle: handle || void 0,
+            maintainAspectRatio: this.config.maintainAspectRatio
+          }
+        }
+      });
+    }
+    this.reset();
+  }
+  cancel() {
+    if (this.state === "idle") return;
+    if (this.state === "vertex-editing") {
+      this.onUpdate({
+        state: "end",
+        transformData: {
+          type: "vertex-edit",
+          changes: {
+            vertices: this.startVertices
+          },
+          metadata: {
+            vertexIndex: this.activeVertexIndex || void 0
+          }
+        }
+      });
+    } else if (this.startElement) {
+      this.onUpdate({
+        state: "end",
+        transformData: {
+          type: this.state === "dragging" ? "move" : "resize",
+          changes: {
+            rect: this.startElement
+          },
+          metadata: this.state === "dragging" ? void 0 : {
+            handle: this.activeHandle || void 0,
+            maintainAspectRatio: this.config.maintainAspectRatio
+          }
+        }
+      });
+    }
+    this.reset();
+  }
+  reset() {
+    this.state = "idle";
+    this.startPoint = null;
+    this.startElement = null;
+    this.activeHandle = null;
+    this.currentPosition = null;
+    this.activeVertexIndex = null;
+    this.startVertices = [];
+  }
+  getCurrentPosition() {
+    return this.currentPosition || this.config.element;
+  }
+  calculateDelta(clientX, clientY) {
+    if (!this.startPoint) return { x: 0, y: 0 };
+    const rawDelta = {
+      x: clientX - this.startPoint.x,
+      y: clientY - this.startPoint.y
+    };
+    return this.transformDelta(rawDelta);
+  }
+  transformDelta(delta) {
+    const { pageRotation = 0, scale = 1 } = this.config;
+    const rad = pageRotation * Math.PI / 2;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const scaledX = delta.x / scale;
+    const scaledY = delta.y / scale;
+    return {
+      x: cos * scaledX + sin * scaledY,
+      y: -sin * scaledX + cos * scaledY
+    };
+  }
+  clampPoint(p) {
+    var _a;
+    const bbox = (_a = this.config.constraints) == null ? void 0 : _a.boundingBox;
+    if (!bbox) return p;
+    return {
+      x: Math.max(0, Math.min(p.x, bbox.width)),
+      y: Math.max(0, Math.min(p.y, bbox.height))
+    };
+  }
+  calculateVertexPosition(clientX, clientY) {
+    if (this.activeVertexIndex === null) return this.startVertices;
+    const delta = this.calculateDelta(clientX, clientY);
+    const newVertices = [...this.startVertices];
+    const currentVertex = newVertices[this.activeVertexIndex];
+    const moved = {
+      x: currentVertex.x + delta.x,
+      y: currentVertex.y + delta.y
+    };
+    newVertices[this.activeVertexIndex] = this.clampPoint(moved);
+    return newVertices;
+  }
+  calculateDragPosition(delta) {
+    if (!this.startElement) return this.config.element;
+    const position = {
+      origin: {
+        x: this.startElement.origin.x + delta.x,
+        y: this.startElement.origin.y + delta.y
+      },
+      size: {
+        width: this.startElement.size.width,
+        height: this.startElement.size.height
+      }
+    };
+    return this.applyConstraints(position);
+  }
+  calculateResizePosition(delta, handle) {
+    var _a;
+    if (!this.startElement) return this.config.element;
+    let {
+      origin: { x, y },
+      size: { width, height }
+    } = this.startElement;
+    switch (handle) {
+      case "se":
+        width += delta.x;
+        height += delta.y;
+        break;
+      case "sw":
+        x += delta.x;
+        width -= delta.x;
+        height += delta.y;
+        break;
+      case "ne":
+        width += delta.x;
+        y += delta.y;
+        height -= delta.y;
+        break;
+      case "nw":
+        x += delta.x;
+        width -= delta.x;
+        y += delta.y;
+        height -= delta.y;
+        break;
+      case "n":
+        y += delta.y;
+        height -= delta.y;
+        break;
+      case "s":
+        height += delta.y;
+        break;
+      case "e":
+        width += delta.x;
+        break;
+      case "w":
+        x += delta.x;
+        width -= delta.x;
+        break;
+    }
+    if (this.config.maintainAspectRatio && this.startElement) {
+      const aspectRatio = this.startElement.size.width / this.startElement.size.height;
+      if (["n", "s", "e", "w"].includes(handle)) {
+        if (handle === "n" || handle === "s") {
+          const newWidth = height * aspectRatio;
+          const widthDiff = newWidth - width;
+          width = newWidth;
+          x -= widthDiff / 2;
+        } else {
+          const newHeight = width / aspectRatio;
+          const heightDiff = newHeight - height;
+          height = newHeight;
+          if (handle === "w") {
+            x = this.startElement.origin.x + this.startElement.size.width - width;
+          }
+          y -= heightDiff / 2;
+        }
+      } else {
+        const widthChange = Math.abs(width - this.startElement.size.width);
+        const heightChange = Math.abs(height - this.startElement.size.height);
+        if (widthChange > heightChange) {
+          height = width / aspectRatio;
+        } else {
+          width = height * aspectRatio;
+        }
+        if (handle.includes("w")) {
+          x = this.startElement.origin.x + this.startElement.size.width - width;
+        }
+        if (handle.includes("n")) {
+          y = this.startElement.origin.y + this.startElement.size.height - height;
+        }
+      }
+    }
+    const bbox = (_a = this.config.constraints) == null ? void 0 : _a.boundingBox;
+    if (bbox) {
+      switch (handle) {
+        case "e":
+          width = Math.min(width, bbox.width - x);
+          break;
+        case "s":
+          height = Math.min(height, bbox.height - y);
+          break;
+        case "se":
+          width = Math.min(width, bbox.width - x);
+          height = Math.min(height, bbox.height - y);
+          break;
+        case "w":
+          if (x < 0) {
+            width += x;
+            x = 0;
+          }
+          break;
+        case "n":
+          if (y < 0) {
+            height += y;
+            y = 0;
+          }
+          break;
+        case "sw":
+          if (x < 0) {
+            width += x;
+            x = 0;
+          }
+          height = Math.min(height, bbox.height - y);
+          break;
+        case "nw":
+          if (x < 0) {
+            width += x;
+            x = 0;
+          }
+          if (y < 0) {
+            height += y;
+            y = 0;
+          }
+          break;
+        case "ne":
+          width = Math.min(width, bbox.width - x);
+          if (y < 0) {
+            height += y;
+            y = 0;
+          }
+          break;
+      }
+    }
+    return this.applyConstraints({ origin: { x, y }, size: { width, height } });
+  }
+  applyConstraints(position) {
+    const { constraints } = this.config;
+    if (!constraints) return position;
+    let {
+      origin: { x, y },
+      size: { width, height }
+    } = position;
+    width = Math.max(constraints.minWidth || 1, width);
+    height = Math.max(constraints.minHeight || 1, height);
+    if (constraints.maxWidth) width = Math.min(constraints.maxWidth, width);
+    if (constraints.maxHeight) height = Math.min(constraints.maxHeight, height);
+    if (constraints.boundingBox) {
+      x = Math.max(0, Math.min(x, constraints.boundingBox.width - width));
+      y = Math.max(0, Math.min(y, constraints.boundingBox.height - height));
+    }
+    return { origin: { x, y }, size: { width, height } };
+  }
+}
+function diagonalCursor(handle, rot) {
+  const diag0 = {
+    nw: "nwse-resize",
+    ne: "nesw-resize",
+    sw: "nesw-resize",
+    se: "nwse-resize"
+  };
+  if (handle === "n" || handle === "s") return "ns-resize";
+  if (handle === "e" || handle === "w") return "ew-resize";
+  if (rot % 2 === 0) return diag0[handle];
+  return { nw: "nesw-resize", ne: "nwse-resize", sw: "nwse-resize", se: "nesw-resize" }[handle];
+}
+function edgeOffset(k, spacing, mode) {
+  const base = -k / 2;
+  if (mode === "center") return base;
+  return mode === "outside" ? base - spacing : base + spacing;
+}
+function describeResizeFromConfig(cfg, ui = {}) {
+  const {
+    handleSize = 8,
+    spacing = 1,
+    offsetMode = "outside",
+    includeSides = false,
+    zIndex = 3,
+    rotationAwareCursor = true
+  } = ui;
+  const rotation = (cfg.pageRotation ?? 0) % 4;
+  const off = (edge) => ({
+    [edge]: edgeOffset(handleSize, spacing, offsetMode) + "px"
+  });
+  const corners = [
+    ["nw", { ...off("top"), ...off("left") }],
+    ["ne", { ...off("top"), ...off("right") }],
+    ["sw", { ...off("bottom"), ...off("left") }],
+    ["se", { ...off("bottom"), ...off("right") }]
+  ];
+  const sides = includeSides ? [
+    ["n", { ...off("top"), left: `calc(50% - ${handleSize / 2}px)` }],
+    ["s", { ...off("bottom"), left: `calc(50% - ${handleSize / 2}px)` }],
+    ["w", { ...off("left"), top: `calc(50% - ${handleSize / 2}px)` }],
+    ["e", { ...off("right"), top: `calc(50% - ${handleSize / 2}px)` }]
+  ] : [];
+  const all = [...corners, ...sides];
+  return all.map(([handle, pos]) => ({
+    handle,
+    style: {
+      position: "absolute",
+      width: handleSize + "px",
+      height: handleSize + "px",
+      borderRadius: "50%",
+      zIndex,
+      cursor: rotationAwareCursor ? diagonalCursor(handle, rotation) : "default",
+      touchAction: "none",
+      ...pos
+    },
+    attrs: { "data-epdf-handle": handle }
+  }));
+}
+function describeVerticesFromConfig(cfg, ui = {}, liveVertices) {
+  const { vertexSize = 12, zIndex = 4 } = ui;
+  const rect = cfg.element;
+  const scale = cfg.scale ?? 1;
+  const verts = liveVertices ?? cfg.vertices ?? [];
+  return verts.map((v, i) => {
+    const left = (v.x - rect.origin.x) * scale - vertexSize / 2;
+    const top = (v.y - rect.origin.y) * scale - vertexSize / 2;
+    return {
+      handle: "nw",
+      // not used; kept for type
+      style: {
+        position: "absolute",
+        left: left + "px",
+        top: top + "px",
+        width: vertexSize + "px",
+        height: vertexSize + "px",
+        borderRadius: "50%",
+        cursor: "pointer",
+        zIndex,
+        touchAction: "none"
+      },
+      attrs: { "data-epdf-vertex": i }
+    };
+  });
+}
+function useDragResize(getOptions) {
+  const config = $.derived(() => {
+    const opts = getOptions();
+    const { onUpdate: onUpdate2, enabled: enabled2, ...rest } = opts;
+    return rest;
+  });
+  const enabled = $.derived(() => getOptions().enabled ?? true);
+  const onUpdate = $.derived(() => getOptions().onUpdate);
+  let controller = $.state(null);
+  $.user_effect(() => {
+    if (!$.get(controller)) {
+      $.set(controller, new DragResizeController($.get(config), (event) => {
+        var _a;
+        return (_a = $.get(onUpdate)) == null ? void 0 : _a(event);
+      }), true);
+    } else {
+      $.get(controller).updateConfig($.get(config));
+    }
+  });
+  const handleDragStart = (e) => {
+    var _a;
+    if (!$.get(enabled)) return;
+    e.preventDefault();
+    e.stopPropagation();
+    (_a = $.get(controller)) == null ? void 0 : _a.startDrag(e.clientX, e.clientY);
+    e.currentTarget.setPointerCapture(e.pointerId);
+  };
+  const handleMove = (e) => {
+    var _a;
+    e.preventDefault();
+    e.stopPropagation();
+    (_a = $.get(controller)) == null ? void 0 : _a.move(e.clientX, e.clientY);
+  };
+  const handleEnd = (e) => {
+    var _a, _b, _c;
+    e.preventDefault();
+    e.stopPropagation();
+    (_a = $.get(controller)) == null ? void 0 : _a.end();
+    (_c = (_b = e.currentTarget).releasePointerCapture) == null ? void 0 : _c.call(_b, e.pointerId);
+  };
+  const createResizeHandler = (handle) => ({
+    onpointerdown: (e) => {
+      var _a;
+      if (!$.get(enabled)) return;
+      e.preventDefault();
+      e.stopPropagation();
+      (_a = $.get(controller)) == null ? void 0 : _a.startResize(handle, e.clientX, e.clientY);
+      e.currentTarget.setPointerCapture(e.pointerId);
+    },
+    onpointermove: handleMove,
+    onpointerup: handleEnd,
+    onpointercancel: handleEnd
+  });
+  const createVertexHandler = (vertexIndex) => ({
+    onpointerdown: (e) => {
+      var _a;
+      if (!$.get(enabled)) return;
+      e.preventDefault();
+      e.stopPropagation();
+      (_a = $.get(controller)) == null ? void 0 : _a.startVertexEdit(vertexIndex, e.clientX, e.clientY);
+      e.currentTarget.setPointerCapture(e.pointerId);
+    },
+    onpointermove: handleMove,
+    onpointerup: handleEnd,
+    onpointercancel: handleEnd
+  });
+  const dragProps = $.derived(() => $.get(enabled) ? {
+    onpointerdown: handleDragStart,
+    onpointermove: handleMove,
+    onpointerup: handleEnd,
+    onpointercancel: handleEnd
+  } : {});
+  return {
+    get dragProps() {
+      return $.get(dragProps);
+    },
+    createResizeProps: createResizeHandler,
+    createVertexProps: createVertexHandler
+  };
+}
+function stylesToString(style) {
+  return Object.entries(style).map(([key, value]) => {
+    const cssKey = key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    return `${cssKey}: ${value}`;
+  }).join("; ");
+}
+function useInteractionHandles(getOpts) {
+  const controller = $.derived(() => getOpts().controller);
+  const resizeUI = $.derived(() => getOpts().resizeUI);
+  const vertexUI = $.derived(() => getOpts().vertexUI);
+  const includeVertices = $.derived(() => getOpts().includeVertices ?? false);
+  const handleAttrs = $.derived(() => getOpts().handleAttrs);
+  const vertexAttrs = $.derived(() => getOpts().vertexAttrs);
+  const dragResize = useDragResize(() => $.get(controller));
+  const resize = $.derived(() => {
+    const desc = describeResizeFromConfig($.get(controller), $.get(resizeUI));
+    return desc.map((d) => {
+      var _a, _b;
+      return {
+        key: (_a = d.attrs) == null ? void 0 : _a["data-epdf-handle"],
+        style: stylesToString(d.style),
+        ...dragResize.createResizeProps(d.handle),
+        ...d.attrs ?? {},
+        ...((_b = $.get(handleAttrs)) == null ? void 0 : _b(d.handle)) ?? {}
+      };
+    });
+  });
+  const vertices = $.derived(() => {
+    if (!$.get(includeVertices)) return [];
+    const desc = describeVerticesFromConfig($.get(controller), $.get(vertexUI), $.get(controller).vertices);
+    return desc.map((d, i) => {
+      var _a;
+      return {
+        key: i,
+        style: stylesToString(d.style),
+        ...dragResize.createVertexProps(i),
+        ...d.attrs ?? {},
+        ...((_a = $.get(vertexAttrs)) == null ? void 0 : _a(i)) ?? {}
+      };
+    });
+  });
+  return {
+    get dragProps() {
+      return dragResize.dragProps;
+    },
+    get resize() {
+      return $.get(resize);
+    },
+    get vertices() {
+      return $.get(vertices);
+    }
+  };
+}
+function doublePress(node, options = {}) {
+  let { onDouble, delay = 300, tolerancePx = 18 } = options;
+  const last = { t: 0, x: 0, y: 0 };
+  const handlePointerUp = (e) => {
+    const ev = e;
+    if (!onDouble) return;
+    if (ev.pointerType === "mouse" || ev.isPrimary === false) return;
+    const now = performance.now();
+    const x = ev.clientX;
+    const y = ev.clientY;
+    const withinTime = now - last.t <= delay;
+    const dx = x - last.x;
+    const dy = y - last.y;
+    const withinDist = dx * dx + dy * dy <= tolerancePx * tolerancePx;
+    if (withinTime && withinDist) onDouble == null ? void 0 : onDouble(ev);
+    last.t = now;
+    last.x = x;
+    last.y = y;
+  };
+  const handleDblClick = (e) => {
+    onDouble == null ? void 0 : onDouble(e);
+  };
+  node.addEventListener("pointerup", handlePointerUp, { capture: true });
+  node.addEventListener("dblclick", handleDblClick);
+  return {
+    update(next) {
+      if (!next) return;
+      onDouble = next.onDouble;
+      delay = next.delay ?? delay;
+      tolerancePx = next.tolerancePx ?? tolerancePx;
+    },
+    destroy() {
+      node.removeEventListener("pointerup", handlePointerUp, { capture: true });
+      node.removeEventListener("dblclick", handleDblClick);
+    }
+  };
+}
+function CounterRotateContainer($$anchor, $$props) {
+  $.push($$props, true);
+  const counterRotation = $.derived(() => getCounterRotation($$props.rect, $$props.rotation));
+  let elementRef = $.state(null);
+  $.user_effect(() => {
+    const element = $.get(elementRef);
+    if (!element) return;
+    const handlePointerDown = (e) => {
+      e.stopPropagation();
+    };
+    const handleTouchStart = (e) => {
+      e.stopPropagation();
+    };
+    element.addEventListener("pointerdown", handlePointerDown, { capture: true });
+    element.addEventListener("touchstart", handleTouchStart, { capture: true });
+    return () => {
+      element.removeEventListener("pointerdown", handlePointerDown, { capture: true });
+      element.removeEventListener("touchstart", handleTouchStart, { capture: true });
+    };
+  });
+  const menuWrapperStyle = $.derived(() => `position: absolute; left: ${$$props.rect.origin.x}px; top: ${$$props.rect.origin.y}px; transform: ${$.get(counterRotation).matrix}; transform-origin: 0 0; width: ${$.get(counterRotation).width}px; height: ${$.get(counterRotation).height}px; pointer-events: none; z-index: 3`);
+  const menuWrapperProps = $.derived(() => ({
+    style: $.get(menuWrapperStyle),
+    ref: (el) => {
+      $.set(elementRef, el, true);
+    }
+  }));
+  var fragment = $.comment();
+  var node = $.first_child(fragment);
+  {
+    var consequent = ($$anchor2) => {
+      var fragment_1 = $.comment();
+      var node_1 = $.first_child(fragment_1);
+      $.snippet(node_1, () => $$props.children, () => ({
+        menuWrapperProps: $.get(menuWrapperProps),
+        matrix: $.get(counterRotation).matrix,
+        rect: {
+          origin: { x: $$props.rect.origin.x, y: $$props.rect.origin.y },
+          size: {
+            width: $.get(counterRotation).width,
+            height: $.get(counterRotation).height
+          }
+        }
+      }));
+      $.append($$anchor2, fragment_1);
+    };
+    $.if(node, ($$render) => {
+      if ($$props.children) $$render(consequent);
+    });
+  }
+  $.append($$anchor, fragment);
+  $.pop();
+}
+function deepToRaw(sourceObj) {
+  const objectIterator = (input) => {
+    if (input === null || input === void 0) {
+      return input;
+    }
+    if (typeof input !== "object") {
+      return input;
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => objectIterator(item));
+    }
+    if (input instanceof Date) {
+      return new Date(input.getTime());
+    }
+    if (input instanceof RegExp) {
+      return new RegExp(input.source, input.flags);
+    }
+    if (Object.prototype.toString.call(input) === "[object Object]") {
+      return Object.keys(input).reduce((acc, key) => {
+        const value = input[key];
+        if (typeof value !== "function") {
+          acc[key] = objectIterator(value);
+        }
+        return acc;
+      }, {});
+    }
+    try {
+      return JSON.parse(JSON.stringify(input));
+    } catch {
+      return void 0;
+    }
+  };
+  return objectIterator(sourceObj);
+}
+export {
+  CounterRotateContainer as CounterRotate,
+  deepToRaw,
+  doublePress,
+  stylesToString,
+  useDragResize,
+  useInteractionHandles
+};
+//# sourceMappingURL=index.js.map