@tldraw/editor 3.14.0-canary.0f41576b87d4 → 3.14.0-canary.103612e26824

package/src/index.ts

@@ -182,10 +182,6 @@ export { BaseBoxShapeUtil, type TLBaseBoxShape } from './lib/editor/shapes/BaseB
 export {
 	ShapeUtil,
 	type TLCropInfo,
-	type TLDragShapesInInfo,
-	type TLDragShapesOutInfo,
-	type TLDragShapesOverInfo,
-	type TLDropShapesOverInfo,
 	type TLGeometryOpts,
 	type TLHandleDragInfo,
 	type TLResizeInfo,
@@ -450,7 +446,6 @@ export { hardResetEditor } from './lib/utils/hardResetEditor'
 export { isAccelKey } from './lib/utils/keyboard'
 export { normalizeWheel } from './lib/utils/normalizeWheel'
 export { refreshPage } from './lib/utils/refreshPage'
-export { getDroppedShapesToNewParents, kickoutOccludedShapes } from './lib/utils/reparenting'
 export {
 	getFontsFromRichText,
 	type RichTextFontVisitor,

package/src/lib/editor/Editor.ts

@@ -5528,7 +5528,7 @@ export class Editor extends EventEmitter<TLEventMap> {
 		if (!id) return undefined
 		const freshShape = this.getShape(id)
 		if (freshShape === undefined || !isShapeId(freshShape.parentId)) return undefined
-		return this.getShape(freshShape.parentId)
+		return this.store.get(freshShape.parentId)
 	}
 
 	/**
@@ -5711,10 +5711,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 					const newPoint = invertedParentTransform.applyToPoint(pagePoint)
 					const newRotation = pageTransform.rotation() - parentPageRotation
 
-					if (shape.id === parentId) {
-						throw Error('Attempted to reparent a shape to itself!')
-					}
-
 					changes.push({
 						id: shape.id,
 						type: shape.type,
@@ -5818,11 +5814,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 		return shapeIds
 	}
 
-	/** @deprecated Use {@link Editor.getDraggingOverShape} instead */
-	getDroppingOverShape(point: Vec, droppingShapes: TLShape[]): TLShape | undefined {
-		return this.getDraggingOverShape(point, droppingShapes)
-	}
-
 	/**
 	 * Get the shape that some shapes should be dropped on at a given point.
 	 *
@@ -5833,33 +5824,35 @@ export class Editor extends EventEmitter<TLEventMap> {
 	 *
 	 * @public
 	 */
-	getDraggingOverShape(point: Vec, droppingShapes: TLShape[]): TLShape | undefined {
-		// get fresh moving shapes
-		const draggingShapes = compact(droppingShapes.map((s) => this.getShape(s))).filter(
-			(s) => !s.isLocked && !this.isShapeHidden(s)
-		)
+	getDroppingOverShape(point: VecLike, droppingShapes: TLShape[] = []) {
+		// starting from the top...
+		const currentPageShapesSorted = this.getCurrentPageShapesSorted()
+		for (let i = currentPageShapesSorted.length - 1; i >= 0; i--) {
+			const shape = currentPageShapesSorted[i]
 
-		const maybeDraggingOverShapes = this.getShapesAtPoint(point, {
-			hitInside: true,
-			margin: 0,
-		}).filter(
-			(s) =>
-				!droppingShapes.includes(s) &&
-				!s.isLocked &&
-				!this.isShapeHidden(s) &&
-				!draggingShapes.includes(s)
-		)
+			if (
+				// ignore hidden shapes
+				this.isShapeHidden(shape) ||
+				// don't allow dropping on selected shapes
+				this.getSelectedShapeIds().includes(shape.id) ||
+				// only allow shapes that can receive children
+				!this.getShapeUtil(shape).canDropShapes(shape, droppingShapes) ||
+				// don't allow dropping a shape on itself or one of it's children
+				droppingShapes.find((s) => s.id === shape.id || this.hasAncestor(shape, s.id))
+			) {
+				continue
+			}
+
+			// Only allow dropping into the masked page bounds of the shape, e.g. when a frame is
+			// partially clipped by its own parent frame
+			const maskedPageBounds = this.getShapeMaskedPageBounds(shape.id)
 
-		for (const maybeDraggingOverShape of maybeDraggingOverShapes) {
-			const shapeUtil = this.getShapeUtil(maybeDraggingOverShape)
-			// Any shape that can handle any dragging interactions is a valid target
 			if (
-				shapeUtil.onDragShapesOver ||
-				shapeUtil.onDragShapesIn ||
-				shapeUtil.onDragShapesOut ||
-				shapeUtil.onDropShapesOver
+				maskedPageBounds &&
+				maskedPageBounds.containsPoint(point) &&
+				this.getShapeGeometry(shape).hitTestPoint(this.getPointInShapeSpace(shape, point), 0, true)
 			) {
-				return maybeDraggingOverShape
+				return shape
 			}
 		}
 	}
@@ -6303,7 +6296,10 @@ export class Editor extends EventEmitter<TLEventMap> {
 			})
 			const shapesToCreate = shapesToCreateWithOriginals.map(({ shape }) => shape)
 
-			if (!this.canCreateShapes(shapesToCreate)) {
+			const maxShapesReached =
+				shapesToCreate.length + this.getCurrentPageShapeIds().size > this.options.maxShapesPerPage
+
+			if (maxShapesReached) {
 				alertMaxShapes(this)
 				return
 			}
@@ -7732,32 +7728,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 		return {}
 	}
 
-	/**
-	 * Get whether the provided shape can be created.
-	 *
-	 * @param shape - The shape or shape IDs to check.
-	 *
-	 * @public
-	 */
-	canCreateShape<T extends TLUnknownShape>(
-		shape: OptionalKeys<TLShapePartial<T>, 'id'> | T['id']
-	): boolean {
-		return this.canCreateShapes([shape])
-	}
-
-	/**
-	 * Get whether the provided shapes can be created.
-	 *
-	 * @param shapes - The shapes or shape IDs to create.
-	 *
-	 * @public
-	 */
-	canCreateShapes<T extends TLUnknownShape>(
-		shapes: (T['id'] | OptionalKeys<TLShapePartial<T>, 'id'>)[]
-	): boolean {
-		return shapes.length + this.getCurrentPageShapeIds().size <= this.options.maxShapesPerPage
-	}
-
 	/**
 	 * Create a single shape.
 	 *
@@ -7804,7 +7774,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 		if (maxShapesReached) {
 			// can't create more shapes than fit on the page
 			alertMaxShapes(this)
-			// todo: throw an error here? Otherwise we'll need to check every time whether the shapes were actually created
 			return this
 		}
 
@@ -7837,10 +7806,9 @@ export class Editor extends EventEmitter<TLEventMap> {
 
 					for (let i = currentPageShapesSorted.length - 1; i >= 0; i--) {
 						const parent = currentPageShapesSorted[i]
-						const util = this.getShapeUtil(parent)
 						if (
-							util.canReceiveNewChildrenOfType(parent, partial.type) &&
 							!this.isShapeHidden(parent) &&
+							this.getShapeUtil(parent).canReceiveNewChildrenOfType(parent, partial.type) &&
 							this.isPointInShape(
 								parent,
 								// If no parent is provided, then we can treat the
@@ -9544,8 +9512,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 			previousPagePoint,
 			currentScreenPoint,
 			currentPagePoint,
-			originScreenPoint,
-			originPagePoint,
 		} = this.inputs
 
 		const { screenBounds } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID)!
@@ -9574,8 +9540,8 @@ export class Editor extends EventEmitter<TLEventMap> {
 		// Reset velocity on pointer down, or when a pinch starts or ends
 		if (info.name === 'pointer_down' || this.inputs.isPinching) {
 			pointerVelocity.set(0, 0)
-			originScreenPoint.setTo(currentScreenPoint)
-			originPagePoint.setTo(currentPagePoint)
+			this.inputs.originScreenPoint.setTo(currentScreenPoint)
+			this.inputs.originPagePoint.setTo(currentPagePoint)
 		}
 
 		// todo: We only have to do this if there are multiple users in the document

package/src/lib/editor/managers/HistoryManager/HistoryManager.ts

@@ -241,9 +241,7 @@ export class HistoryManager<R extends UnknownRecord> {
 	}
 
 	bailToMark(id: string) {
-		if (id) {
-			this._undo({ pushToRedoStack: false, toMark: id })
-		}
+		this._undo({ pushToRedoStack: false, toMark: id })
 
 		return this
 	}

package/src/lib/editor/shapes/ShapeUtil.ts

@@ -4,15 +4,12 @@ import { LegacyMigrations, MigrationSequence } from '@tldraw/store'
 import {
 	RecordProps,
 	TLHandle,
-	TLParentId,
 	TLPropsMigrations,
 	TLShape,
 	TLShapeCrop,
-	TLShapeId,
 	TLShapePartial,
 	TLUnknownShape,
 } from '@tldraw/tlschema'
-import { IndexKey } from '@tldraw/utils'
 import { ReactElement } from 'react'
 import { Box, SelectionHandle } from '../../primitives/Box'
 import { Vec } from '../../primitives/Vec'
@@ -390,6 +387,17 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 		return false
 	}
 
+	/**
+	 * Get whether the shape can receive children of a given type.
+	 *
+	 * @param shape - The shape type.
+	 * @param shapes - The shapes that are being dropped.
+	 * @public
+	 */
+	canDropShapes(_shape: Shape, _shapes: TLShape[]) {
+		return false
+	}
+
 	/**
 	 * Get the shape as an SVG object.
 	 *
@@ -509,16 +517,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	): Omit<TLShapePartial<Shape>, 'id' | 'type'> | undefined | void
 
 	/**
-	 * A callback called when some other shapes are dragged into this one. This fires when the shapes are dragged over the shape for the first time.
-	 *
-	 * @param shape - The shape.
-	 * @param shapes - The shapes that are being dragged in.
-	 * @public
-	 */
-	onDragShapesIn?(shape: Shape, shapes: TLShape[], info: TLDragShapesInInfo): void
-
-	/**
-	 * A callback called when some other shapes are dragged over this one. This fires when the shapes are dragged over the shape for the first time (after the onDragShapesIn callback), and again on every update while the shapes are being dragged.
+	 * A callback called when some other shapes are dragged over this one.
 	 *
 	 * @example
 	 *
@@ -532,7 +531,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	 * @param shapes - The shapes that are being dragged over this one.
 	 * @public
 	 */
-	onDragShapesOver?(shape: Shape, shapes: TLShape[], info: TLDragShapesOverInfo): void
+	onDragShapesOver?(shape: Shape, shapes: TLShape[]): void
 
 	/**
 	 * A callback called when some other shapes are dragged out of this one.
@@ -541,7 +540,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	 * @param shapes - The shapes that are being dragged out.
 	 * @public
 	 */
-	onDragShapesOut?(shape: Shape, shapes: TLShape[], info: TLDragShapesOutInfo): void
+	onDragShapesOut?(shape: Shape, shapes: TLShape[]): void
 
 	/**
 	 * A callback called when some other shapes are dropped over this one.
@@ -550,7 +549,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	 * @param shapes - The shapes that are being dropped over this one.
 	 * @public
 	 */
-	onDropShapesOver?(shape: Shape, shapes: TLShape[], info: TLDropShapesOverInfo): void
+	onDropShapesOver?(shape: Shape, shapes: TLShape[]): void
 
 	/**
 	 * A callback called when a shape starts being resized.
@@ -749,36 +748,6 @@ export interface TLCropInfo<T extends TLShape> {
 	aspectRatioLocked?: boolean
 }
 
-/** @public */
-export interface TLDragShapesInInfo {
-	initialDraggingOverShapeId: TLShapeId | null
-	prevDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
-/** @public */
-export interface TLDragShapesOverInfo {
-	initialDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
-/** @public */
-export interface TLDragShapesOutInfo {
-	nextDraggingOverShapeId: TLShapeId | null
-	initialDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
-/** @public */
-export interface TLDropShapesOverInfo {
-	initialDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
 /**
  * The type of resize.
  *

package/src/lib/editor/tools/BaseBoxShapeTool/children/Pointing.ts

@@ -11,33 +11,29 @@ export class Pointing extends StateNode {
 	static override id = 'pointing'
 
 	override onPointerMove(info: TLPointerEventInfo) {
-		const { editor } = this
-		if (editor.inputs.isDragging) {
-			const { originPagePoint } = editor.inputs
+		if (this.editor.inputs.isDragging) {
+			const { originPagePoint } = this.editor.inputs
 
 			const shapeType = (this.parent as BaseBoxShapeTool)!.shapeType
 
 			const id = createShapeId()
 
-			const creatingMarkId = editor.markHistoryStoppingPoint(`creating_box:${id}`)
-			const newPoint = maybeSnapToGrid(originPagePoint, editor)
-
-			// Allow this to trigger the max shapes reached alert
-			this.editor.createShapes<TLBaseBoxShape>([
-				{
-					id,
-					type: shapeType,
-					x: newPoint.x,
-					y: newPoint.y,
-					props: {
-						w: 1,
-						h: 1,
+			const creatingMarkId = this.editor.markHistoryStoppingPoint(`creating_box:${id}`)
+			const newPoint = maybeSnapToGrid(originPagePoint, this.editor)
+			this.editor
+				.createShapes<TLBaseBoxShape>([
+					{
+						id,
+						type: shapeType,
+						x: newPoint.x,
+						y: newPoint.y,
+						props: {
+							w: 1,
+							h: 1,
+						},
 					},
-				},
-			])
-			const shape = editor.getShape(id)
-			if (!shape) this.cancel()
-			editor.select(id)
+				])
+				.select(id)
 
 			const parent = this.parent as BaseBoxShapeTool
 			this.editor.setCurrentTool(
@@ -83,7 +79,6 @@ export class Pointing extends StateNode {
 
 		this.editor.markHistoryStoppingPoint(`creating_box:${id}`)
 
-		// Allow this to trigger the max shapes reached alert
 		// todo: add scale here when dynamic size is enabled (is this still needed?)
 		this.editor.createShapes<TLBaseBoxShape>([
 			{

package/src/lib/primitives/geometry/Geometry2d.ts

@@ -44,7 +44,6 @@ export const Geometry2dFilters: {
 /** @public */
 export interface TransformedGeometry2dOptions {
 	isLabel?: boolean
-	isEmptyLabel?: boolean
 	isInternal?: boolean
 	debugColor?: string
 	ignore?: boolean
@@ -58,24 +57,20 @@ export interface Geometry2dOptions extends TransformedGeometry2dOptions {
 
 /** @public */
 export abstract class Geometry2d {
-	// todo: consider making accessors for these too, so that they can be overridden in subclasses by geometries with more complex logic
 	isFilled = false
 	isClosed = true
 	isLabel = false
-	isEmptyLabel = false
 	isInternal = false
 	debugColor?: string
 	ignore?: boolean
 
 	constructor(opts: Geometry2dOptions) {
-		const { isLabel = false, isEmptyLabel = false, isInternal = false } = opts
 		this.isFilled = opts.isFilled
 		this.isClosed = opts.isClosed
+		this.isLabel = opts.isLabel ?? false
+		this.isInternal = opts.isInternal ?? false
 		this.debugColor = opts.debugColor
 		this.ignore = opts.ignore
-		this.isLabel = isLabel
-		this.isEmptyLabel = isEmptyLabel
-		this.isInternal = isInternal
 	}
 
 	isExcludedByFilter(filters?: Geometry2dFilters) {

package/src/version.ts

@@ -1,9 +1,9 @@
 // This file is automatically generated by internal/scripts/refresh-assets.ts.
 // Do not edit manually. Or do, I'm a comment, not a cop.
 
-export const version = '3.14.0-canary.0f41576b87d4'
+export const version = '3.14.0-canary.103612e26824'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-06-26T16:20:43.145Z',
-	patch: '2025-06-26T16:20:43.145Z',
+	minor: '2025-06-24T10:50:50.049Z',
+	patch: '2025-06-24T10:50:50.049Z',
 }

package/dist-cjs/lib/utils/reparenting.js

@@ -1,232 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var reparenting_exports = {};
-__export(reparenting_exports, {
-  doesGeometryOverlapPolygon: () => doesGeometryOverlapPolygon,
-  getDroppedShapesToNewParents: () => getDroppedShapesToNewParents,
-  kickoutOccludedShapes: () => kickoutOccludedShapes
-});
-module.exports = __toCommonJS(reparenting_exports);
-var import_state = require("@tldraw/state");
-var import_utils = require("@tldraw/utils");
-var import_Group2d = require("../primitives/geometry/Group2d");
-var import_intersect = require("../primitives/intersect");
-var import_utils2 = require("../primitives/utils");
-function kickoutOccludedShapes(editor, shapeIds, opts) {
-  const parentsToCheck = /* @__PURE__ */ new Set();
-  for (const id of shapeIds) {
-    const shape = editor.getShape(id);
-    if (!shape) continue;
-    parentsToCheck.add(shape);
-    const parent = editor.getShape(shape.parentId);
-    if (!parent) continue;
-    parentsToCheck.add(parent);
-  }
-  const parentsToLostChildren = /* @__PURE__ */ new Map();
-  for (const parent of parentsToCheck) {
-    const childIds = editor.getSortedChildIdsForParent(parent);
-    if (opts?.filter && !opts.filter(parent)) {
-      parentsToLostChildren.set(parent, childIds);
-    } else {
-      const overlappingChildren = getOverlappingShapes(editor, parent.id, childIds);
-      if (overlappingChildren.length < childIds.length) {
-        parentsToLostChildren.set(
-          parent,
-          childIds.filter((id) => !overlappingChildren.includes(id))
-        );
-      }
-    }
-  }
-  const sortedShapeIds = editor.getCurrentPageShapesSorted().map((s) => s.id);
-  const parentsToNewChildren = {};
-  for (const [prevParent, lostChildrenIds] of parentsToLostChildren) {
-    const lostChildren = (0, import_utils.compact)(lostChildrenIds.map((id) => editor.getShape(id)));
-    const { reparenting, remainingShapesToReparent } = getDroppedShapesToNewParents(
-      editor,
-      lostChildren,
-      (shape, maybeNewParent) => {
-        if (opts?.filter && !opts.filter(maybeNewParent)) return false;
-        return maybeNewParent.id !== prevParent.id && sortedShapeIds.indexOf(maybeNewParent.id) < sortedShapeIds.indexOf(shape.id);
-      }
-    );
-    reparenting.forEach((childrenToReparent, newParentId) => {
-      if (childrenToReparent.length === 0) return;
-      if (!parentsToNewChildren[newParentId]) {
-        parentsToNewChildren[newParentId] = {
-          parentId: newParentId,
-          shapeIds: []
-        };
-      }
-      parentsToNewChildren[newParentId].shapeIds.push(...childrenToReparent.map((s) => s.id));
-    });
-    if (remainingShapesToReparent.size > 0) {
-      const newParentId = editor.findShapeAncestor(prevParent, (s) => editor.isShapeOfType(s, "group"))?.id ?? editor.getCurrentPageId();
-      remainingShapesToReparent.forEach((shape) => {
-        if (!parentsToNewChildren[newParentId]) {
-          let insertIndexKey;
-          const oldParentSiblingIds = editor.getSortedChildIdsForParent(newParentId);
-          const oldParentIndex = oldParentSiblingIds.indexOf(prevParent.id);
-          if (oldParentIndex > -1) {
-            const siblingsIndexAbove = oldParentSiblingIds[oldParentIndex + 1];
-            const indexKeyAbove = siblingsIndexAbove ? editor.getShape(siblingsIndexAbove).index : (0, import_utils.getIndexAbove)(prevParent.index);
-            insertIndexKey = (0, import_utils.getIndexBetween)(prevParent.index, indexKeyAbove);
-          } else {
-          }
-          parentsToNewChildren[newParentId] = {
-            parentId: newParentId,
-            shapeIds: [],
-            index: insertIndexKey
-          };
-        }
-        parentsToNewChildren[newParentId].shapeIds.push(shape.id);
-      });
-    }
-  }
-  editor.run(() => {
-    Object.values(parentsToNewChildren).forEach(({ parentId, shapeIds: shapeIds2, index }) => {
-      if (shapeIds2.length === 0) return;
-      shapeIds2.sort((a, b) => sortedShapeIds.indexOf(a) < sortedShapeIds.indexOf(b) ? -1 : 1);
-      editor.reparentShapes(shapeIds2, parentId, index);
-    });
-  });
-}
-function getOverlappingShapes(editor, shape, otherShapes) {
-  if (otherShapes.length === 0) {
-    return import_state.EMPTY_ARRAY;
-  }
-  const parentPageBounds = editor.getShapePageBounds(shape);
-  if (!parentPageBounds) return import_state.EMPTY_ARRAY;
-  const parentGeometry = editor.getShapeGeometry(shape);
-  const parentPageTransform = editor.getShapePageTransform(shape);
-  const parentPageCorners = parentPageTransform.applyToPoints(parentGeometry.vertices);
-  const parentPageMaskVertices = editor.getShapeMask(shape);
-  const parentPagePolygon = parentPageMaskVertices ? (0, import_intersect.intersectPolygonPolygon)(parentPageMaskVertices, parentPageCorners) : parentPageCorners;
-  if (!parentPagePolygon) return import_state.EMPTY_ARRAY;
-  return otherShapes.filter((childId) => {
-    const shapePageBounds = editor.getShapePageBounds(childId);
-    if (!shapePageBounds || !parentPageBounds.includes(shapePageBounds)) return false;
-    const parentPolygonInShapeShape = editor.getShapePageTransform(childId).clone().invert().applyToPoints(parentPagePolygon);
-    const geometry = editor.getShapeGeometry(childId);
-    return doesGeometryOverlapPolygon(geometry, parentPolygonInShapeShape);
-  });
-}
-function doesGeometryOverlapPolygon(geometry, parentCornersInShapeSpace) {
-  if (geometry instanceof import_Group2d.Group2d) {
-    return geometry.children.some(
-      (childGeometry) => doesGeometryOverlapPolygon(childGeometry, parentCornersInShapeSpace)
-    );
-  }
-  const { vertices, center, isFilled, isEmptyLabel, isClosed } = geometry;
-  if (isEmptyLabel) return false;
-  if (vertices.some((v) => (0, import_utils2.pointInPolygon)(v, parentCornersInShapeSpace))) {
-    return true;
-  }
-  if (isClosed) {
-    if (isFilled) {
-      if ((0, import_utils2.pointInPolygon)(center, parentCornersInShapeSpace)) {
-        return true;
-      }
-      if (parentCornersInShapeSpace.every((v) => (0, import_utils2.pointInPolygon)(v, vertices))) {
-        return true;
-      }
-    }
-    if ((0, import_intersect.polygonsIntersect)(parentCornersInShapeSpace, vertices)) {
-      return true;
-    }
-  } else {
-    if ((0, import_intersect.polygonIntersectsPolyline)(parentCornersInShapeSpace, vertices)) {
-      return true;
-    }
-  }
-  return false;
-}
-function getDroppedShapesToNewParents(editor, shapes, cb) {
-  const shapesToActuallyCheck = new Set(shapes);
-  const movingGroups = /* @__PURE__ */ new Set();
-  for (const shape of shapes) {
-    const parent = editor.getShapeParent(shape);
-    if (parent && editor.isShapeOfType(parent, "group")) {
-      if (!movingGroups.has(parent)) {
-        movingGroups.add(parent);
-      }
-    }
-  }
-  for (const movingGroup of movingGroups) {
-    const children = (0, import_utils.compact)(
-      editor.getSortedChildIdsForParent(movingGroup).map((id) => editor.getShape(id))
-    );
-    for (const child of children) {
-      shapesToActuallyCheck.delete(child);
-    }
-    shapesToActuallyCheck.add(movingGroup);
-  }
-  const shapeGroupIds = /* @__PURE__ */ new Map();
-  const reparenting = /* @__PURE__ */ new Map();
-  const remainingShapesToReparent = new Set(shapesToActuallyCheck);
-  const potentialParentShapes = editor.getCurrentPageShapesSorted().filter(
-    (s) => editor.getShapeUtil(s).canReceiveNewChildrenOfType?.(s, s.type) && !remainingShapesToReparent.has(s)
-  );
-  parentCheck: for (let i = potentialParentShapes.length - 1; i >= 0; i--) {
-    const parentShape = potentialParentShapes[i];
-    const parentShapeContainingGroupId = editor.findShapeAncestor(
-      parentShape,
-      (s) => editor.isShapeOfType(s, "group")
-    )?.id;
-    const parentGeometry = editor.getShapeGeometry(parentShape);
-    const parentPageTransform = editor.getShapePageTransform(parentShape);
-    const parentPageMaskVertices = editor.getShapeMask(parentShape);
-    const parentPageCorners = parentPageTransform.applyToPoints(parentGeometry.vertices);
-    const parentPagePolygon = parentPageMaskVertices ? (0, import_intersect.intersectPolygonPolygon)(parentPageMaskVertices, parentPageCorners) : parentPageCorners;
-    if (!parentPagePolygon) continue parentCheck;
-    const childrenToReparent = [];
-    shapeCheck: for (const shape of remainingShapesToReparent) {
-      if (parentShape.id === shape.id) continue shapeCheck;
-      if (cb && !cb(shape, parentShape)) continue shapeCheck;
-      if (!shapeGroupIds.has(shape.id)) {
-        shapeGroupIds.set(
-          shape.id,
-          editor.findShapeAncestor(shape, (s) => editor.isShapeOfType(s, "group"))?.id
-        );
-      }
-      const shapeGroupId = shapeGroupIds.get(shape.id);
-      if (shapeGroupId !== parentShapeContainingGroupId) continue shapeCheck;
-      if (editor.findShapeAncestor(parentShape, (s) => shape.id === s.id)) continue shapeCheck;
-      const parentPolygonInShapeSpace = editor.getShapePageTransform(shape).clone().invert().applyToPoints(parentPagePolygon);
-      if (doesGeometryOverlapPolygon(editor.getShapeGeometry(shape), parentPolygonInShapeSpace)) {
-        if (!editor.getShapeUtil(parentShape).canReceiveNewChildrenOfType?.(parentShape, shape.type))
-          continue shapeCheck;
-        if (shape.parentId !== parentShape.id) {
-          childrenToReparent.push(shape);
-        }
-        remainingShapesToReparent.delete(shape);
-        continue shapeCheck;
-      }
-    }
-    if (childrenToReparent.length) {
-      reparenting.set(parentShape.id, childrenToReparent);
-    }
-  }
-  return {
-    // these are the shapes that will be reparented to new parents
-    reparenting,
-    // these are the shapes that will be reparented to the page or their ancestral group
-    remainingShapesToReparent
-  };
-}
-//# sourceMappingURL=reparenting.js.map