@elixpo/lixsketch 5.5.23 → 5.6.2

package/dist/react/EventDispatcher-7LAK7GQ7.js

@@ -0,0 +1,1097 @@
+"use client";
+import {
+  enterEditMode,
+  handleTextMouseDown,
+  handleTextMouseMove,
+  handleTextMouseUp
+} from "./chunk-GQUZPON4.js";
+import {
+  handleCodeMouseDown,
+  handleCodeMouseMove,
+  handleCodeMouseUp
+} from "./chunk-M6TMN76K.js";
+import {
+  handleMouseDownImage,
+  handleMouseMoveImage,
+  handleMouseUpImage
+} from "./chunk-LJR7EVW2.js";
+import {
+  handleMouseDownIcon,
+  handleMouseMoveIcon,
+  handleMouseUpIcon
+} from "./chunk-APTOPAOY.js";
+import {
+  handleMouseDown as handleMouseDown4,
+  handleMouseMove as handleMouseMove4,
+  handleMouseUp as handleMouseUp4
+} from "./chunk-LSHZYN77.js";
+import {
+  handleMouseDown as handleMouseDown5,
+  handleMouseMove as handleMouseMove5,
+  handleMouseUp as handleMouseUp5
+} from "./chunk-XOWNCYE4.js";
+import {
+  handleMultiSelectionMouseDown,
+  handleMultiSelectionMouseMove,
+  handleMultiSelectionMouseUp,
+  isMultiSelecting,
+  multiSelection,
+  removeMultiSelectionRect
+} from "./chunk-K5RY4EV7.js";
+import {
+  Frame
+} from "./chunk-K5BG5MHY.js";
+import {
+  handleMouseDownRect,
+  handleMouseMoveRect,
+  handleMouseUpRect
+} from "./chunk-7CM5XQDN.js";
+import {
+  handleMouseDown as handleMouseDown2,
+  handleMouseMove as handleMouseMove2,
+  handleMouseUp as handleMouseUp2
+} from "./chunk-XFL4R5ZF.js";
+import {
+  handleMouseDown as handleMouseDown3,
+  handleMouseMove as handleMouseMove3,
+  handleMouseUp as handleMouseUp3
+} from "./chunk-RGMDWLRJ.js";
+import {
+  normalizeWebEmbedUrl
+} from "./chunk-QZI4UIE5.js";
+import "./chunk-DNAG7ML6.js";
+import "./chunk-PAKA6HUX.js";
+import {
+  handleMouseDown,
+  handleMouseMove,
+  handleMouseUp
+} from "./chunk-XYUFEIZR.js";
+import {
+  pushCreateAction,
+  pushFrameAttachmentAction,
+  pushOptionsChangeAction
+} from "./chunk-6GPEWDRB.js";
+
+// src/tools/shapeRecognitionTool.js
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MAX_POINTS = 96;
+var MIN_SCREEN_SAMPLE_PX = 4;
+var MIN_SHAPE_SIZE = 8;
+var drawing = false;
+var points = [];
+var previewPath = null;
+var previewFrame = 0;
+var latestPrediction = null;
+function getThemeStroke() {
+  return document.body?.classList.contains("theme-dark") ? "#f7f4ff" : "#211a33";
+}
+function getSVGPoint(event) {
+  const viewBox = svg.viewBox.baseVal;
+  const rect = svg.getBoundingClientRect();
+  return {
+    x: viewBox.x + (event.clientX - rect.left) / rect.width * viewBox.width,
+    y: viewBox.y + (event.clientY - rect.top) / rect.height * viewBox.height,
+    pressure: event.pressure || 0.5
+  };
+}
+function distance(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function orientedBounds(sample, angle) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  let minU = Infinity;
+  let maxU = -Infinity;
+  let minV = Infinity;
+  let maxV = -Infinity;
+  for (const point of sample) {
+    const u = point.x * cos + point.y * sin;
+    const v = -point.x * sin + point.y * cos;
+    minU = Math.min(minU, u);
+    maxU = Math.max(maxU, u);
+    minV = Math.min(minV, v);
+    maxV = Math.max(maxV, v);
+  }
+  const centerU = (minU + maxU) / 2;
+  const centerV = (minV + maxV) / 2;
+  return {
+    center: {
+      x: centerU * cos - centerV * sin,
+      y: centerU * sin + centerV * cos
+    },
+    width: Math.max(MIN_SHAPE_SIZE, maxU - minU),
+    height: Math.max(MIN_SHAPE_SIZE, maxV - minV),
+    angle,
+    minU,
+    maxU,
+    minV,
+    maxV
+  };
+}
+function principalAngle(sample) {
+  let meanX = 0;
+  let meanY = 0;
+  for (const point of sample) {
+    meanX += point.x;
+    meanY += point.y;
+  }
+  meanX /= sample.length;
+  meanY /= sample.length;
+  let xx = 0;
+  let yy = 0;
+  let xy = 0;
+  for (const point of sample) {
+    const dx = point.x - meanX;
+    const dy = point.y - meanY;
+    xx += dx * dx;
+    yy += dy * dy;
+    xy += dx * dy;
+  }
+  if (Math.abs(xx - yy) + Math.abs(xy) < 1e-3) return 0;
+  return Math.atan2(2 * xy, xx - yy) / 2;
+}
+function rectangleAngle(sample) {
+  let x = 0;
+  let y = 0;
+  for (let index = 1; index < sample.length; index += 1) {
+    const dx = sample[index].x - sample[index - 1].x;
+    const dy = sample[index].y - sample[index - 1].y;
+    const length = Math.hypot(dx, dy);
+    if (length === 0) continue;
+    const angle = Math.atan2(dy, dx) * 4;
+    x += Math.cos(angle) * length;
+    y += Math.sin(angle) * length;
+  }
+  return Math.atan2(y, x) / 4;
+}
+function closedShapePrediction(sample, pathLength) {
+  const rectBounds = orientedBounds(sample, rectangleAngle(sample));
+  const ellipseBounds = orientedBounds(sample, principalAngle(sample));
+  let rectangleError = 0;
+  let ellipseError = 0;
+  const rectCos = Math.cos(rectBounds.angle);
+  const rectSin = Math.sin(rectBounds.angle);
+  const ellipseCos = Math.cos(ellipseBounds.angle);
+  const ellipseSin = Math.sin(ellipseBounds.angle);
+  const rectHalfW = rectBounds.width / 2;
+  const rectHalfH = rectBounds.height / 2;
+  const ellipseHalfW = ellipseBounds.width / 2;
+  const ellipseHalfH = ellipseBounds.height / 2;
+  for (const point of sample) {
+    const rectDx = point.x - rectBounds.center.x;
+    const rectDy = point.y - rectBounds.center.y;
+    const rectU = Math.abs(rectDx * rectCos + rectDy * rectSin) / rectHalfW;
+    const rectV = Math.abs(-rectDx * rectSin + rectDy * rectCos) / rectHalfH;
+    rectangleError += Math.min(Math.abs(1 - rectU), Math.abs(1 - rectV));
+    const ellipseDx = point.x - ellipseBounds.center.x;
+    const ellipseDy = point.y - ellipseBounds.center.y;
+    const ellipseU = (ellipseDx * ellipseCos + ellipseDy * ellipseSin) / ellipseHalfW;
+    const ellipseV = (-ellipseDx * ellipseSin + ellipseDy * ellipseCos) / ellipseHalfH;
+    ellipseError += Math.abs(1 - Math.hypot(ellipseU, ellipseV));
+  }
+  rectangleError /= sample.length;
+  ellipseError /= sample.length;
+  const rectangle = rectangleError <= ellipseError * 1.08;
+  const bestError = rectangle ? rectangleError : ellipseError;
+  if (bestError > 0.24) {
+    return { type: "freehand", points: sample.map((point) => ({ ...point })), pathLength };
+  }
+  const bounds = rectangle ? rectBounds : ellipseBounds;
+  return {
+    type: rectangle ? "rectangle" : "circle",
+    ...bounds,
+    pathLength
+  };
+}
+function predictDrawnShape(sample) {
+  if (!Array.isArray(sample) || sample.length < 2) return null;
+  const start2 = sample[0];
+  let pathLength = 0;
+  let farthestIndex = 1;
+  let farthestDistance = 0;
+  let minX = start2.x;
+  let maxX = start2.x;
+  let minY = start2.y;
+  let maxY = start2.y;
+  for (let index = 1; index < sample.length; index += 1) {
+    pathLength += distance(sample[index - 1], sample[index]);
+    const fromStart = distance(start2, sample[index]);
+    if (fromStart > farthestDistance) {
+      farthestDistance = fromStart;
+      farthestIndex = index;
+    }
+    minX = Math.min(minX, sample[index].x);
+    maxX = Math.max(maxX, sample[index].x);
+    minY = Math.min(minY, sample[index].y);
+    maxY = Math.max(maxY, sample[index].y);
+  }
+  const diagonal = Math.max(MIN_SHAPE_SIZE, Math.hypot(maxX - minX, maxY - minY));
+  const end = sample[sample.length - 1];
+  const closed = sample.length >= 8 && distance(start2, end) <= diagonal * 0.28 && pathLength >= diagonal * 2.05;
+  if (closed) return closedShapePrediction(sample, pathLength);
+  const tip = sample[farthestIndex];
+  let afterTipLength = 0;
+  for (let index = farthestIndex + 1; index < sample.length; index += 1) {
+    afterTipLength += distance(sample[index - 1], sample[index]);
+  }
+  let shaftLength = 0;
+  for (let index = 1; index <= farthestIndex; index += 1) {
+    shaftLength += distance(sample[index - 1], sample[index]);
+  }
+  const arrow = farthestIndex >= Math.floor(sample.length * 0.45) && farthestIndex < sample.length - 2 && afterTipLength >= diagonal * 0.18 && distance(end, tip) <= diagonal * 0.48 && farthestDistance / Math.max(shaftLength, 1) >= 0.86;
+  const directDistance = distance(start2, end);
+  const line = !arrow && directDistance / Math.max(pathLength, 1) >= 0.92;
+  if (!arrow && !line) {
+    return { type: "freehand", points: sample.map((point) => ({ ...point })), pathLength };
+  }
+  return {
+    type: arrow ? "arrow" : "line",
+    start: { ...start2 },
+    end: arrow ? { ...tip } : { ...end },
+    width: Math.max(MIN_SHAPE_SIZE, maxX - minX),
+    height: Math.max(MIN_SHAPE_SIZE, maxY - minY),
+    pathLength
+  };
+}
+function rotatedPoint(center, x, y, angle) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  return { x: center.x + x * cos - y * sin, y: center.y + x * sin + y * cos };
+}
+function pathForPrediction(prediction) {
+  if (!prediction) return "";
+  if (prediction.type === "rectangle") {
+    const halfW = prediction.width / 2;
+    const halfH = prediction.height / 2;
+    const corners = [
+      rotatedPoint(prediction.center, -halfW, -halfH, prediction.angle),
+      rotatedPoint(prediction.center, halfW, -halfH, prediction.angle),
+      rotatedPoint(prediction.center, halfW, halfH, prediction.angle),
+      rotatedPoint(prediction.center, -halfW, halfH, prediction.angle)
+    ];
+    return `M ${corners[0].x} ${corners[0].y} L ${corners[1].x} ${corners[1].y} L ${corners[2].x} ${corners[2].y} L ${corners[3].x} ${corners[3].y} Z`;
+  }
+  if (prediction.type === "circle") {
+    const rx = prediction.width / 2;
+    const ry = prediction.height / 2;
+    const start3 = rotatedPoint(prediction.center, rx, 0, prediction.angle);
+    const opposite = rotatedPoint(prediction.center, -rx, 0, prediction.angle);
+    const rotation = prediction.angle * 180 / Math.PI;
+    return `M ${start3.x} ${start3.y} A ${rx} ${ry} ${rotation} 1 0 ${opposite.x} ${opposite.y} A ${rx} ${ry} ${rotation} 1 0 ${start3.x} ${start3.y}`;
+  }
+  if (prediction.type === "freehand") {
+    if (!prediction.points.length) return "";
+    return prediction.points.reduce((path2, point, index) => `${path2}${index === 0 ? "M" : " L"} ${point.x} ${point.y}`, "");
+  }
+  const { start: start2, end } = prediction;
+  let path = `M ${start2.x} ${start2.y} L ${end.x} ${end.y}`;
+  if (prediction.type === "arrow") {
+    const angle = Math.atan2(end.y - start2.y, end.x - start2.x);
+    const head = Math.min(24 / (window.currentZoom || 1), distance(start2, end) * 0.25);
+    const left = rotatedPoint(end, -head, head * 0.55, angle);
+    const right = rotatedPoint(end, -head, -head * 0.55, angle);
+    path += ` M ${left.x} ${left.y} L ${end.x} ${end.y} L ${right.x} ${right.y}`;
+  }
+  return path;
+}
+function ensurePreview() {
+  if (previewPath?.isConnected) return;
+  previewPath = document.createElementNS(SVG_NS, "path");
+  previewPath.dataset.recognitionPreview = "true";
+  previewPath.setAttribute("fill", "rgba(148, 148, 158, 0.06)");
+  previewPath.setAttribute("stroke", "#9696a0");
+  previewPath.setAttribute("stroke-width", "2");
+  previewPath.setAttribute("stroke-dasharray", "5 7");
+  previewPath.setAttribute("stroke-linecap", "round");
+  previewPath.setAttribute("stroke-linejoin", "round");
+  previewPath.setAttribute("vector-effect", "non-scaling-stroke");
+  previewPath.setAttribute("pointer-events", "none");
+  svg.appendChild(previewPath);
+}
+function renderPreview() {
+  previewFrame = 0;
+  if (!drawing) return;
+  latestPrediction = predictDrawnShape(points);
+  ensurePreview();
+  previewPath.setAttribute("d", pathForPrediction(latestPrediction));
+  previewPath.setAttribute("fill", latestPrediction?.type === "rectangle" || latestPrediction?.type === "circle" ? "rgba(148, 148, 158, 0.06)" : "none");
+}
+function schedulePreview() {
+  if (!previewFrame) previewFrame = requestAnimationFrame(renderPreview);
+}
+function cleanupPreview() {
+  if (previewFrame) cancelAnimationFrame(previewFrame);
+  previewFrame = 0;
+  previewPath?.remove();
+  previewPath = null;
+}
+function currentStyle() {
+  const settings = window.freehandToolSettings || {};
+  const outline = settings.strokeStyle || "solid";
+  return {
+    stroke: settings.strokeColor || getThemeStroke(),
+    fill: "transparent",
+    fillStyle: "none",
+    strokeWidth: settings.strokeWidth || 2,
+    strokeDasharray: outline === "dashed" ? "10,10" : outline === "dotted" ? "2,8" : "",
+    outline
+  };
+}
+function attachToContainingFrame(shape) {
+  for (let index = shapes.length - 1; index >= 0; index -= 1) {
+    const frame2 = shapes[index];
+    if (frame2.shapeName !== "frame" || typeof frame2.isShapeInFrame !== "function") continue;
+    if (!frame2.isShapeInFrame(shape)) continue;
+    frame2.addShapeToFrame(shape);
+    pushFrameAttachmentAction(frame2, shape, "attach", null);
+    break;
+  }
+}
+function createPredictedShape(prediction) {
+  if (!prediction) return null;
+  const style = currentStyle();
+  let shape = null;
+  if (prediction.type === "rectangle") {
+    shape = new window.Rectangle(
+      prediction.center.x - prediction.width / 2,
+      prediction.center.y - prediction.height / 2,
+      prediction.width,
+      prediction.height,
+      style
+    );
+    shape.rotation = prediction.angle * 180 / Math.PI;
+    shape.draw();
+  } else if (prediction.type === "circle") {
+    shape = new window.Circle(
+      prediction.center.x,
+      prediction.center.y,
+      prediction.width / 2,
+      prediction.height / 2,
+      style
+    );
+    shape.rotation = prediction.angle * 180 / Math.PI;
+    shape.draw();
+  } else if (prediction.type === "freehand") {
+    const brush = window.freehandToolSettings || {};
+    shape = new window.FreehandStroke(
+      prediction.points.map((point) => [point.x, point.y, point.pressure || 0.5]),
+      {
+        stroke: style.stroke,
+        strokeWidth: style.strokeWidth,
+        strokeStyle: style.outline,
+        thinning: brush.thinning ?? 0.5,
+        roughness: brush.roughness || "smooth",
+        strokeOpacity: brush.opacity ?? 1
+      }
+    );
+  } else if (prediction.type === "arrow") {
+    shape = new window.Arrow(prediction.start, prediction.end, {
+      stroke: style.stroke,
+      strokeWidth: style.strokeWidth,
+      arrowOutlineStyle: style.outline,
+      arrowCurved: "straight"
+    });
+  } else {
+    shape = new window.Line(prediction.start, prediction.end, {
+      stroke: style.stroke,
+      strokeWidth: style.strokeWidth,
+      strokeDasharray: style.strokeDasharray,
+      roughness: 1.5,
+      bowing: 1
+    });
+  }
+  shapes.push(shape);
+  pushCreateAction(shape);
+  attachToContainingFrame(shape);
+  return shape;
+}
+function handleShapeRecognitionDown(event) {
+  if (!window.isShapeRecognitionToolActive || event.button !== 0) return;
+  drawing = true;
+  points = [getSVGPoint(event)];
+  latestPrediction = null;
+  ensurePreview();
+  schedulePreview();
+}
+function handleShapeRecognitionMove(event) {
+  if (!drawing || !window.isShapeRecognitionToolActive) return;
+  const point = getSVGPoint(event);
+  const last = points[points.length - 1];
+  const threshold = MIN_SCREEN_SAMPLE_PX / (window.currentZoom || 1);
+  if (distance(last, point) < threshold) return;
+  if (points.length < MAX_POINTS) {
+    points.push(point);
+  } else {
+    points = [points[0], ...points.slice(2).filter((_, index) => index % 2 === 0), point];
+  }
+  schedulePreview();
+}
+function handleShapeRecognitionUp(event) {
+  if (!drawing) return;
+  drawing = false;
+  const rect = svg.getBoundingClientRect();
+  if (event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom) {
+    const point = getSVGPoint(event);
+    if (distance(points[points.length - 1], point) > 0) points.push(point);
+  }
+  latestPrediction = predictDrawnShape(points);
+  cleanupPreview();
+  const prediction = latestPrediction;
+  points = [];
+  latestPrediction = null;
+  if (!prediction || prediction.pathLength < MIN_SHAPE_SIZE) return;
+  const shape = createPredictedShape(prediction);
+  if (!shape) return;
+  if (window.__sketchStoreApi) window.__sketchStoreApi.setActiveTool("select", { afterDraw: true });
+  currentShape = shape;
+  if (shape.shapeName === "freehandStroke" && typeof shape.selectStroke === "function") {
+    shape.selectStroke();
+  } else {
+    shape.isSelected = true;
+    if (typeof shape.addAnchors === "function") shape.addAnchors();
+  }
+}
+function cancelShapeRecognition() {
+  drawing = false;
+  points = [];
+  latestPrediction = null;
+  cleanupPreview();
+}
+window.__cancelShapeRecognition = cancelShapeRecognition;
+
+// src/tools/paintBucketTool.js
+var CLOSED_SHAPES = /* @__PURE__ */ new Set(["rectangle", "circle"]);
+window.paintBucketSettings = window.paintBucketSettings || {
+  fillColor: "#A98DEB",
+  fillStyle: "solid"
+};
+function getSVGPoint2(event) {
+  const viewBox = svg.viewBox.baseVal;
+  const rect = svg.getBoundingClientRect();
+  return {
+    x: viewBox.x + (event.clientX - rect.left) / rect.width * viewBox.width,
+    y: viewBox.y + (event.clientY - rect.top) / rect.height * viewBox.height
+  };
+}
+function findClosedShapeAt(x, y) {
+  for (let index = shapes.length - 1; index >= 0; index -= 1) {
+    const shape = shapes[index];
+    if (!CLOSED_SHAPES.has(shape?.shapeName) || typeof shape.contains !== "function") continue;
+    if (shape.contains(x, y)) return shape;
+  }
+  return null;
+}
+function handlePaintBucketDown(event) {
+  if (!window.isPaintBucketToolActive || event.button !== 0) return;
+  const { x, y } = getSVGPoint2(event);
+  const shape = findClosedShapeAt(x, y);
+  if (!shape) {
+    window.dispatchEvent(new CustomEvent("lixsketch:bucket-miss"));
+    return;
+  }
+  const settings = window.paintBucketSettings;
+  const transparent = settings.fillStyle === "none" || settings.fillStyle === "transparent";
+  const nextFill = transparent ? "transparent" : settings.fillColor;
+  const nextStyle = transparent ? "none" : settings.fillStyle;
+  if (shape.options.fill === nextFill && shape.options.fillStyle === nextStyle) return;
+  const oldOptions = { ...shape.options };
+  const newOptions = { ...shape.options, fill: nextFill, fillStyle: nextStyle };
+  pushOptionsChangeAction(shape, oldOptions, newOptions);
+  shape.options = newOptions;
+  shape.draw();
+  window.dispatchEvent(new CustomEvent("lixsketch:bucket-filled", { detail: { shapeID: shape.shapeID } }));
+}
+
+// src/tools/lassoTool.js
+var MAX_POINTS2 = 192;
+var MIN_SAMPLE_PX = 4;
+var points2 = [];
+var preview = null;
+var drawing2 = false;
+function coords(e) {
+  const vb = svg.viewBox.baseVal;
+  const rect = svg.getBoundingClientRect();
+  return { x: vb.x + (e.clientX - rect.left) / rect.width * vb.width, y: vb.y + (e.clientY - rect.top) / rect.height * vb.height };
+}
+function pointInPolygon(point, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const a = polygon[i], b = polygon[j];
+    if (a.y > point.y !== b.y > point.y && point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y || Number.EPSILON) + a.x) inside = !inside;
+  }
+  return inside;
+}
+function boundsPoints(shape) {
+  if ((shape.shapeName === "line" || shape.shapeName === "arrow") && shape.startPoint && shape.endPoint) return [shape.startPoint, shape.endPoint];
+  if (shape.shapeName === "freehandStroke" && Array.isArray(shape.points)) {
+    const step = Math.max(1, Math.ceil(shape.points.length / 16));
+    return shape.points.filter((_, i) => i % step === 0).map((p) => ({ x: p[0], y: p[1] }));
+  }
+  let x = shape.x || 0, y = shape.y || 0, width = shape.width || 0, height = shape.height || 0;
+  if (shape.shapeName === "circle") {
+    x = shape.x - shape.rx;
+    y = shape.y - shape.ry;
+    width = shape.rx * 2;
+    height = shape.ry * 2;
+  }
+  if ((!width || !height) && shape.group?.getBBox) {
+    try {
+      const box = shape.group.getBBox();
+      x = box.x;
+      y = box.y;
+      width = box.width;
+      height = box.height;
+    } catch {
+    }
+  }
+  const raw = [{ x, y }, { x: x + width, y }, { x: x + width, y: y + height }, { x, y: y + height }, { x: x + width / 2, y: y + height / 2 }];
+  const rotation = Number(shape.rotation) || 0;
+  if (!rotation) return raw;
+  const cx = x + width / 2, cy = y + height / 2, angle = rotation * Math.PI / 180;
+  return raw.map((p) => ({ x: cx + (p.x - cx) * Math.cos(angle) - (p.y - cy) * Math.sin(angle), y: cy + (p.x - cx) * Math.sin(angle) + (p.y - cy) * Math.cos(angle) }));
+}
+function cleanup() {
+  preview?.remove();
+  preview = null;
+  points2 = [];
+  drawing2 = false;
+}
+function handleLassoDown(e) {
+  if (!window.isLassoToolActive) return;
+  cleanup();
+  multiSelection.clearSelection();
+  drawing2 = true;
+  points2 = [coords(e)];
+  preview = document.createElementNS("http://www.w3.org/2000/svg", "path");
+  preview.setAttribute("fill", "rgba(139, 118, 214, .10)");
+  preview.setAttribute("stroke", "#a78bfa");
+  preview.setAttribute("stroke-dasharray", "5 4");
+  preview.setAttribute("vector-effect", "non-scaling-stroke");
+  preview.style.pointerEvents = "none";
+  svg.appendChild(preview);
+}
+function handleLassoMove(e) {
+  if (!drawing2) return;
+  const p = coords(e), last = points2[points2.length - 1];
+  const min = MIN_SAMPLE_PX / (window.currentZoom || 1);
+  if (Math.hypot(p.x - last.x, p.y - last.y) < min) return;
+  if (points2.length < MAX_POINTS2) points2.push(p);
+  else points2[points2.length - 1] = p;
+  preview?.setAttribute("d", `M ${points2.map((v) => `${v.x} ${v.y}`).join(" L ")} Z`);
+}
+function handleLassoUp() {
+  if (!drawing2) return;
+  const polygon = points2.slice();
+  cleanup();
+  window.__sketchStoreApi?.setActiveTool("select", { afterDraw: true });
+  if (polygon.length >= 3 && Array.isArray(window.shapes)) {
+    const selected = window.shapes.filter((shape) => boundsPoints(shape).every((p) => pointInPolygon(p, polygon)));
+    const filtered = selected.filter((shape) => !shape.parentFrame || !selected.includes(shape.parentFrame));
+    filtered.forEach((shape) => {
+      multiSelection.selectedShapes.add(shape);
+      shape.isSelected = true;
+    });
+    if (filtered.length) multiSelection.updateControls();
+    window.currentShape = filtered.length === 1 ? filtered[0] : null;
+  }
+}
+function cancelLasso() {
+  cleanup();
+}
+window.__cancelLasso = cancelLasso;
+
+// src/tools/webEmbedTool.js
+var frame = null;
+var start = null;
+function coords2(e) {
+  const vb = svg.viewBox.baseVal, rect = svg.getBoundingClientRect();
+  return { x: vb.x + (e.clientX - rect.left) / rect.width * vb.width, y: vb.y + (e.clientY - rect.top) / rect.height * vb.height };
+}
+function placeWebEmbed(urlValue) {
+  const url = normalizeWebEmbedUrl(urlValue);
+  if (!url || typeof svg === "undefined") return null;
+  window.__sketchStoreApi?.setActiveTool("select");
+  const viewBox = svg.viewBox.baseVal;
+  const width = Math.min(640, Math.max(320, viewBox.width * 0.56));
+  const height = width * 9 / 16;
+  const x = viewBox.x + (viewBox.width - width) / 2;
+  const y = viewBox.y + (viewBox.height - height) / 2;
+  const placedFrame = new Frame(x, y, width, height, {
+    frameName: "Web embed",
+    frameType: "web-embed",
+    webEmbedURL: url,
+    stroke: "#8b76d6",
+    strokeWidth: 2
+  });
+  shapes.push(placedFrame);
+  pushCreateAction(placedFrame);
+  currentShape = placedFrame;
+  placedFrame.selectFrame();
+  window.__pendingWebEmbedURL = null;
+  return placedFrame;
+}
+function handleWebEmbedDown(e) {
+  const url = normalizeWebEmbedUrl(window.__pendingWebEmbedURL);
+  if (!window.isWebEmbedToolActive || !url) {
+    window.__showWebEmbedModal?.();
+    return;
+  }
+  start = coords2(e);
+  frame = new Frame(start.x, start.y, 0, 0, { frameName: "Web embed", frameType: "web-embed", webEmbedURL: url, stroke: "#8b76d6", strokeWidth: 2 });
+  shapes.push(frame);
+  currentShape = frame;
+}
+function handleWebEmbedMove(e) {
+  if (!frame || !start) return;
+  const p = coords2(e);
+  frame.x = Math.min(start.x, p.x);
+  frame.y = Math.min(start.y, p.y);
+  frame.width = Math.abs(p.x - start.x);
+  frame.height = Math.abs(p.y - start.y);
+  frame.draw();
+}
+function handleWebEmbedUp() {
+  if (!frame) return;
+  if (frame.width < 40 || frame.height < 30) {
+    frame.width = 560;
+    frame.height = 315;
+  }
+  frame.draw();
+  pushCreateAction(frame);
+  const placedFrame = frame;
+  window.__pendingWebEmbedURL = null;
+  frame = null;
+  start = null;
+  window.__sketchStoreApi?.setActiveTool("select", { afterDraw: true });
+  currentShape = placedFrame;
+  placedFrame.selectFrame();
+}
+window.__placeWebEmbed = placeWebEmbed;
+
+// src/core/EventDispatcher.js
+var EDGE_THRESHOLD = 40;
+var SCROLL_SPEED = 8;
+var _autoScrollRAF = null;
+function _autoScroll(e) {
+  if (!(e.buttons & 1)) {
+    _stopAutoScroll();
+    return;
+  }
+  if (typeof currentViewBox === "undefined" || typeof currentZoom === "undefined") return;
+  if (typeof isPanning !== "undefined" && isPanning) return;
+  if (typeof isPanningToolActive !== "undefined" && isPanningToolActive) return;
+  const rect = svg.getBoundingClientRect();
+  const mx = e.clientX - rect.left;
+  const my = e.clientY - rect.top;
+  let dx = 0, dy = 0;
+  if (mx < EDGE_THRESHOLD) dx = -SCROLL_SPEED * (1 - mx / EDGE_THRESHOLD);
+  else if (mx > rect.width - EDGE_THRESHOLD) dx = SCROLL_SPEED * (1 - (rect.width - mx) / EDGE_THRESHOLD);
+  if (my < EDGE_THRESHOLD) dy = -SCROLL_SPEED * (1 - my / EDGE_THRESHOLD);
+  else if (my > rect.height - EDGE_THRESHOLD) dy = SCROLL_SPEED * (1 - (rect.height - my) / EDGE_THRESHOLD);
+  if (e.clientX < rect.left) dx = -SCROLL_SPEED;
+  else if (e.clientX > rect.right) dx = SCROLL_SPEED;
+  if (e.clientY < rect.top) dy = -SCROLL_SPEED;
+  else if (e.clientY > rect.bottom) dy = SCROLL_SPEED;
+  if (dx === 0 && dy === 0) {
+    _stopAutoScroll();
+    return;
+  }
+  const scale = 1 / currentZoom;
+  currentViewBox.x += dx * scale;
+  currentViewBox.y += dy * scale;
+  svg.setAttribute("viewBox", `${currentViewBox.x} ${currentViewBox.y} ${currentViewBox.width} ${currentViewBox.height}`);
+  if (typeof freehandCanvas !== "undefined" && freehandCanvas !== svg) {
+    freehandCanvas.setAttribute("viewBox", `${currentViewBox.x} ${currentViewBox.y} ${currentViewBox.width} ${currentViewBox.height}`);
+  }
+}
+function _startAutoScroll() {
+  if (_autoScrollRAF) return;
+  const tick = () => {
+    if (_lastDragEvent) _autoScroll(_lastDragEvent);
+    _autoScrollRAF = requestAnimationFrame(tick);
+  };
+  _autoScrollRAF = requestAnimationFrame(tick);
+}
+function _stopAutoScroll() {
+  if (_autoScrollRAF) {
+    cancelAnimationFrame(_autoScrollRAF);
+    _autoScrollRAF = null;
+  }
+  _lastDragEvent = null;
+}
+var _lastDragEvent = null;
+var _documentDragActive = false;
+function _onDocumentDragMove(e) {
+  _lastDragEvent = e;
+  const rect = svg.getBoundingClientRect();
+  const clampedX = Math.max(rect.left, Math.min(rect.right, e.clientX));
+  const clampedY = Math.max(rect.top, Math.min(rect.bottom, e.clientY));
+  const clampedEvent = new PointerEvent(e.type, {
+    clientX: clampedX,
+    clientY: clampedY,
+    buttons: e.buttons,
+    button: e.button,
+    ctrlKey: e.ctrlKey,
+    shiftKey: e.shiftKey,
+    altKey: e.altKey,
+    metaKey: e.metaKey
+  });
+  handleMainMouseMove(clampedEvent);
+}
+function _onDocumentDragUp(e) {
+  _stopAutoScroll();
+  document.removeEventListener("pointermove", _onDocumentDragMove);
+  document.removeEventListener("pointerup", _onDocumentDragUp);
+  _documentDragActive = false;
+  handleMainMouseUp(e);
+}
+var handleMainMouseDown = (e) => {
+  if (!e.target) return;
+  if (e.button === 1 || e.button === 2 || window.__spacePanActive) return;
+  removeMultiSelectionRect();
+  if (!isSelectionToolActive) {
+    if (multiSelection.selectedShapes.size > 0) {
+      multiSelection.clearSelection();
+    }
+    if (currentShape && typeof currentShape.removeSelection === "function") {
+      currentShape.removeSelection();
+      currentShape = null;
+    }
+    if (typeof disableAllSideBars === "function") {
+      disableAllSideBars();
+    }
+  }
+  if (window.isLassoToolActive) {
+    handleLassoDown(e);
+  } else if (window.isWebEmbedToolActive) {
+    handleWebEmbedDown(e);
+  } else if (window.isShapeRecognitionToolActive) {
+    handleShapeRecognitionDown(e);
+  } else if (window.isPaintBucketToolActive) {
+    handlePaintBucketDown(e);
+  } else if (isSquareToolActive) {
+    handleMouseDownRect(e);
+  } else if (isArrowToolActive) {
+    handleMouseDown(e);
+  } else if (isCircleToolActive) {
+    handleMouseDown2(e);
+  } else if (isImageToolActive) {
+    handleMouseDownImage(e);
+  } else if (isLineToolActive) {
+    handleMouseDown3(e);
+  } else if (isPaintToolActive) {
+    handleMouseDown5(e);
+  } else if (isTextToolActive) {
+    const targetCodeGroup = e.target.closest('g[data-type="code-group"]');
+    const targetTextGroup = e.target.closest('g[data-type="text-group"]');
+    if (targetCodeGroup && !targetTextGroup) {
+      handleCodeMouseDown(e);
+    } else if (isTextInCodeMode && !targetTextGroup && !targetCodeGroup) {
+      handleCodeMouseDown(e);
+    } else {
+      handleTextMouseDown(e);
+    }
+  } else if (isFrameToolActive) {
+    handleMouseDown4(e);
+  } else if (isIconToolActive) {
+    handleMouseDownIcon(e);
+  } else if (isSelectionToolActive) {
+    if (handleMultiSelectionMouseDown(e)) {
+      return;
+    }
+    const prevShape = currentShape;
+    let handled = false;
+    if (currentShape?.shapeName === "rectangle") {
+      handleMouseDownRect(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "arrow") {
+      handleMouseDown(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "circle") {
+      handleMouseDown2(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "image") {
+      handleMouseDownImage(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "line") {
+      handleMouseDown3(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "freehandStroke") {
+      handleMouseDown5(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "text") {
+      handleTextMouseDown(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "frame") {
+      handleMouseDown4(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "icon") {
+      handleMouseDownIcon(e);
+      handled = true;
+    } else if (currentShape?.shapeName === "code") {
+      handleCodeMouseDown(e);
+      handled = true;
+    }
+    if (handled && prevShape && !currentShape) {
+      handled = false;
+    }
+    if (!handled) {
+      const originalCurrentShape = currentShape;
+      handleMouseDownRect(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDown2(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDown(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDownImage(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDown3(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDown5(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleTextMouseDown(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDown4(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleMouseDownIcon(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      handleCodeMouseDown(e);
+      if (currentShape && currentShape !== originalCurrentShape) return;
+      if (currentShape === originalCurrentShape) {
+        if (currentShape) {
+          currentShape.removeSelection();
+          currentShape = null;
+        }
+      }
+    }
+  }
+};
+var handleMainMouseMove = (e) => {
+  if (window.__spacePanPointerActive) return;
+  if (e.buttons & 1) {
+    _lastDragEvent = e;
+    _startAutoScroll();
+  } else {
+    _stopAutoScroll();
+  }
+  if (window.isLassoToolActive) {
+    handleLassoMove(e);
+  } else if (window.isWebEmbedToolActive) {
+    handleWebEmbedMove(e);
+  } else if (window.isShapeRecognitionToolActive) {
+    handleShapeRecognitionMove(e);
+  } else if (window.isPaintBucketToolActive) {
+    return;
+  } else if (isSquareToolActive) {
+    handleMouseMoveRect(e);
+  } else if (isArrowToolActive) {
+    handleMouseMove(e);
+  } else if (isCircleToolActive) {
+    handleMouseMove2(e);
+  } else if (isImageToolActive) {
+    handleMouseMoveImage(e);
+  } else if (isLineToolActive) {
+    handleMouseMove3(e);
+  } else if (isPaintToolActive) {
+    handleMouseMove5(e);
+  } else if (isTextToolActive) {
+    handleTextMouseMove(e);
+    handleCodeMouseMove(e);
+  } else if (isFrameToolActive) {
+    handleMouseMove4(e);
+  } else if (isIconToolActive) {
+    handleMouseMoveIcon(e);
+  } else if (isSelectionToolActive) {
+    if (isMultiSelecting || multiSelection.isDragging || multiSelection.isResizing || multiSelection.isRotating) {
+      if (handleMultiSelectionMouseMove(e)) {
+        return;
+      }
+    }
+    if (currentShape?.shapeName === "rectangle") {
+      handleMouseMoveRect(e);
+    } else if (currentShape?.shapeName === "arrow") {
+      handleMouseMove(e);
+    } else if (currentShape?.shapeName === "circle") {
+      handleMouseMove2(e);
+    } else if (currentShape?.shapeName === "image") {
+      handleMouseMoveImage(e);
+    } else if (currentShape?.shapeName === "line") {
+      handleMouseMove3(e);
+    } else if (currentShape?.shapeName === "freehandStroke") {
+      handleMouseMove5(e);
+    } else if (currentShape?.shapeName === "text") {
+      handleTextMouseMove(e);
+    } else if (currentShape?.shapeName === "frame") {
+      handleMouseMove4(e);
+    } else if (currentShape?.shapeName === "icon") {
+      handleMouseMoveIcon(e);
+    } else if (currentShape?.shapeName === "code") {
+      handleCodeMouseMove(e);
+    } else {
+      if (handleMultiSelectionMouseMove(e)) {
+        return;
+      }
+      handleMouseMoveRect(e);
+      handleMouseMove(e);
+      handleMouseMove2(e);
+      handleMouseMoveImage(e);
+      handleMouseMove3(e);
+      handleMouseMove5(e);
+      handleTextMouseMove(e);
+      handleMouseMove4(e);
+      handleMouseMoveIcon(e);
+      handleCodeMouseMove(e);
+    }
+  }
+};
+var handleMainMouseUp = (e) => {
+  if (window.__spacePanPointerActive) return;
+  _stopAutoScroll();
+  if (window.isLassoToolActive) {
+    handleLassoUp(e);
+  } else if (window.isWebEmbedToolActive) {
+    handleWebEmbedUp(e);
+  } else if (window.isShapeRecognitionToolActive) {
+    handleShapeRecognitionUp(e);
+  } else if (window.isPaintBucketToolActive) {
+    return;
+  } else if (isSquareToolActive) {
+    handleMouseUpRect(e);
+  } else if (isArrowToolActive) {
+    handleMouseUp(e);
+  } else if (isCircleToolActive) {
+    handleMouseUp2(e);
+  } else if (isImageToolActive) {
+    handleMouseUpImage(e);
+  } else if (isLineToolActive) {
+    handleMouseUp3(e);
+  } else if (isPaintToolActive) {
+    handleMouseUp5(e);
+  } else if (isTextToolActive) {
+    handleTextMouseUp(e);
+    handleCodeMouseUp(e);
+  } else if (isFrameToolActive) {
+    handleMouseUp4(e);
+  } else if (isIconToolActive) {
+    handleMouseUpIcon(e);
+  } else if (isSelectionToolActive) {
+    if (isMultiSelecting || multiSelection.isDragging || multiSelection.isResizing || multiSelection.isRotating) {
+      handleMultiSelectionMouseUp(e);
+      return;
+    }
+    if (currentShape?.shapeName === "rectangle") {
+      handleMouseUpRect(e);
+    } else if (currentShape?.shapeName === "arrow") {
+      handleMouseUp(e);
+    } else if (currentShape?.shapeName === "circle") {
+      handleMouseUp2(e);
+    } else if (currentShape?.shapeName === "image") {
+      handleMouseUpImage(e);
+    } else if (currentShape?.shapeName === "line") {
+      handleMouseUp3(e);
+    } else if (currentShape?.shapeName === "freehandStroke") {
+      handleMouseUp5(e);
+    } else if (currentShape?.shapeName === "text") {
+      handleTextMouseUp(e);
+    } else if (currentShape?.shapeName === "frame") {
+      handleMouseUp4(e);
+    } else if (currentShape?.shapeName === "icon") {
+      handleMouseUpIcon(e);
+    } else if (currentShape?.shapeName === "code") {
+      handleCodeMouseUp(e);
+    } else {
+      handleMultiSelectionMouseUp(e);
+      handleMouseUpRect(e);
+      handleMouseUp(e);
+      handleMouseUp2(e);
+      handleMouseUpImage(e);
+      handleMouseUp3(e);
+      handleMouseUp5(e);
+      handleTextMouseUp(e);
+      handleMouseUp4(e);
+      handleMouseUpIcon(e);
+      handleCodeMouseUp(e);
+    }
+  }
+};
+var handleMainMouseLeave = (e) => {
+  if (window.__spacePanPointerActive) return;
+  if (e.buttons & 1) {
+    _lastDragEvent = e;
+    _startAutoScroll();
+    if (!_documentDragActive) {
+      _documentDragActive = true;
+      document.addEventListener("pointermove", _onDocumentDragMove);
+      document.addEventListener("pointerup", _onDocumentDragUp);
+    }
+    return;
+  }
+  handleMainMouseUp(e);
+  removeMultiSelectionRect();
+  if (typeof window.forceCleanupEraserTrail === "function") {
+    window.forceCleanupEraserTrail();
+  }
+  if (typeof isDrawing !== "undefined" && isDrawing) {
+    isDrawing = false;
+    if (typeof lasers !== "undefined" && lasers.length > 0 && typeof fadeLaserTrail === "function") {
+      const lastLaser = lasers[lasers.length - 1];
+      fadeLaserTrail(lastLaser);
+    }
+  }
+};
+var _boundSvg = null;
+function _onMouseEnter(e) {
+  if (_documentDragActive) {
+    document.removeEventListener("pointermove", _onDocumentDragMove);
+    document.removeEventListener("pointerup", _onDocumentDragUp);
+    _documentDragActive = false;
+  }
+}
+var handleMainDblClick = (e) => {
+  if (!e.target) return;
+  const targetTextGroup = e.target.closest('g[data-type="text-group"]');
+  if (targetTextGroup) {
+    e.stopPropagation();
+    enterEditMode(targetTextGroup);
+  }
+};
+function initEventDispatcher(svgEl) {
+  if (_boundSvg) cleanupEventDispatcher();
+  const target = svgEl || svg;
+  target.addEventListener("pointerdown", handleMainMouseDown);
+  target.addEventListener("pointermove", handleMainMouseMove);
+  target.addEventListener("pointerup", handleMainMouseUp);
+  target.addEventListener("pointerleave", handleMainMouseLeave);
+  target.addEventListener("pointerenter", _onMouseEnter);
+  target.addEventListener("dblclick", handleMainDblClick);
+  _boundSvg = target;
+}
+function cleanupEventDispatcher() {
+  _stopAutoScroll();
+  if (_documentDragActive) {
+    document.removeEventListener("pointermove", _onDocumentDragMove);
+    document.removeEventListener("pointerup", _onDocumentDragUp);
+    _documentDragActive = false;
+  }
+  if (_boundSvg) {
+    _boundSvg.removeEventListener("pointerdown", handleMainMouseDown);
+    _boundSvg.removeEventListener("pointermove", handleMainMouseMove);
+    _boundSvg.removeEventListener("pointerup", handleMainMouseUp);
+    _boundSvg.removeEventListener("pointerleave", handleMainMouseLeave);
+    _boundSvg.removeEventListener("pointerenter", _onMouseEnter);
+    _boundSvg.removeEventListener("dblclick", handleMainDblClick);
+    _boundSvg = null;
+  }
+}
+if (typeof svg !== "undefined" && svg) {
+  initEventDispatcher(svg);
+}
+export {
+  cleanupEventDispatcher,
+  handleMainMouseDown,
+  handleMainMouseLeave,
+  handleMainMouseMove,
+  handleMainMouseUp,
+  initEventDispatcher
+};
+//# sourceMappingURL=EventDispatcher-7LAK7GQ7.js.map