@excalidraw/element 0.18.0-f0063e113 → 0.18.0-f5d54ac5a

package/dist/dev/index.js

@@ -8127,7 +8127,8 @@ var LinearElementEditor = class _LinearElementEditor {
   segmentMidPointHoveredCoords;
   elbowed;
   customLineAngle;
-  constructor(element, elementsMap) {
+  isEditing;
+  constructor(element, elementsMap, isEditing = false) {
     this.elementId = element.id;
     if (!pointsEqual6(element.points[0], pointFrom8(0, 0))) {
       console.error("Linear element is not normalized", Error().stack);
@@ -8158,6 +8159,7 @@ var LinearElementEditor = class _LinearElementEditor {
     this.segmentMidPointHoveredCoords = null;
     this.elbowed = isElbowArrow(element) && element.elbowed;
     this.customLineAngle = null;
+    this.isEditing = isEditing;
   }
   // ---------------------------------------------------------------------------
   // static methods
@@ -8175,11 +8177,11 @@ var LinearElementEditor = class _LinearElementEditor {
     return null;
   }
   static handleBoxSelection(event, appState, setState, elementsMap) {
-    if (!appState.editingLinearElement || !appState.selectionElement) {
+    if (!appState.selectedLinearElement?.isEditing || !appState.selectionElement) {
       return false;
     }
-    const { editingLinearElement } = appState;
-    const { selectedPointsIndices, elementId } = editingLinearElement;
+    const { selectedLinearElement } = appState;
+    const { selectedPointsIndices, elementId } = selectedLinearElement;
     const element = _LinearElementEditor.getElement(elementId, elementsMap);
     if (!element) {
       return false;
@@ -8201,8 +8203,8 @@ var LinearElementEditor = class _LinearElementEditor {
       return true;
     });
     setState({
-      editingLinearElement: {
-        ...editingLinearElement,
+      selectedLinearElement: {
+        ...selectedLinearElement,
         selectedPointsIndices: nextSelectedPoints.length ? nextSelectedPoints : null
       }
     });
@@ -8356,7 +8358,6 @@ var LinearElementEditor = class _LinearElementEditor {
       };
       return {
         ...app.state,
-        editingLinearElement: app.state.editingLinearElement ? newLinearElementEditor : null,
         selectedLinearElement: newLinearElementEditor,
         suggestedBindings
       };
@@ -8440,7 +8441,7 @@ var LinearElementEditor = class _LinearElementEditor {
   }
   static getEditorMidPoints = (element, elementsMap, appState) => {
     const boundText = getBoundTextElement(element, elementsMap);
-    if (!isElbowArrow(element) && !appState.editingLinearElement && element.points.length > 2 && !boundText) {
+    if (!isElbowArrow(element) && !appState.selectedLinearElement?.isEditing && element.points.length > 2 && !boundText) {
       return [];
     }
     const points = _LinearElementEditor.getPointsGlobalCoordinates(
@@ -8490,7 +8491,7 @@ var LinearElementEditor = class _LinearElementEditor {
       element,
       elementsMap
     );
-    if (points.length >= 3 && !appState.editingLinearElement && !isElbowArrow(element)) {
+    if (points.length >= 3 && !appState.selectedLinearElement?.isEditing && !isElbowArrow(element)) {
       return null;
     }
     const threshold = (_LinearElementEditor.POINT_HANDLE_SIZE + 1) / appState.zoom.value;
@@ -8630,7 +8631,7 @@ var LinearElementEditor = class _LinearElementEditor {
         segmentMidpoint,
         elementsMap
       );
-    } else if (event.altKey && appState.editingLinearElement) {
+    } else if (event.altKey && appState.selectedLinearElement?.isEditing) {
       if (linearElementEditor.lastUncommittedPoint == null) {
         scene.mutateElement(element, {
           points: [
@@ -8740,14 +8741,14 @@ var LinearElementEditor = class _LinearElementEditor {
   }
   static handlePointerMove(event, scenePointerX, scenePointerY, app) {
     const appState = app.state;
-    if (!appState.editingLinearElement) {
+    if (!appState.selectedLinearElement?.isEditing) {
       return null;
     }
-    const { elementId, lastUncommittedPoint } = appState.editingLinearElement;
+    const { elementId, lastUncommittedPoint } = appState.selectedLinearElement;
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const element = _LinearElementEditor.getElement(elementId, elementsMap);
     if (!element) {
-      return appState.editingLinearElement;
+      return appState.selectedLinearElement;
     }
     const { points } = element;
     const lastPoint = points[points.length - 1];
@@ -8755,10 +8756,10 @@ var LinearElementEditor = class _LinearElementEditor {
       if (lastPoint === lastUncommittedPoint) {
         _LinearElementEditor.deletePoints(element, app, [points.length - 1]);
       }
-      return {
-        ...appState.editingLinearElement,
+      return appState.selectedLinearElement?.lastUncommittedPoint ? {
+        ...appState.selectedLinearElement,
         lastUncommittedPoint: null
-      };
+      } : appState.selectedLinearElement;
     }
     let newPoint;
     if (shouldRotateWithDiscreteAngle(event) && points.length >= 2) {
@@ -8778,8 +8779,8 @@ var LinearElementEditor = class _LinearElementEditor {
       newPoint = _LinearElementEditor.createPointAt(
         element,
         elementsMap,
-        scenePointerX - appState.editingLinearElement.pointerOffset.x,
-        scenePointerY - appState.editingLinearElement.pointerOffset.y,
+        scenePointerX - appState.selectedLinearElement.pointerOffset.x,
+        scenePointerY - appState.selectedLinearElement.pointerOffset.y,
         event[KEYS2.CTRL_OR_CMD] || isElbowArrow(element) ? null : app.getEffectiveGridSize()
       );
     }
@@ -8800,7 +8801,7 @@ var LinearElementEditor = class _LinearElementEditor {
       _LinearElementEditor.addPoints(element, app.scene, [newPoint]);
     }
     return {
-      ...appState.editingLinearElement,
+      ...appState.selectedLinearElement,
       lastUncommittedPoint: element.points[element.points.length - 1]
     };
   }
@@ -8906,11 +8907,11 @@ var LinearElementEditor = class _LinearElementEditor {
   // ---------------------------------------------------------------------------
   static duplicateSelectedPoints(appState, scene) {
     invariant6(
-      appState.editingLinearElement,
+      appState.selectedLinearElement?.isEditing,
       "Not currently editing a linear element"
     );
     const elementsMap = scene.getNonDeletedElementsMap();
-    const { selectedPointsIndices, elementId } = appState.editingLinearElement;
+    const { selectedPointsIndices, elementId } = appState.selectedLinearElement;
     const element = _LinearElementEditor.getElement(elementId, elementsMap);
     invariant6(
       element,
@@ -8957,14 +8958,14 @@ var LinearElementEditor = class _LinearElementEditor {
     }
     return {
       ...appState,
-      editingLinearElement: {
-        ...appState.editingLinearElement,
+      selectedLinearElement: {
+        ...appState.selectedLinearElement,
         selectedPointsIndices: nextSelectedIndices
       }
     };
   }
   static deletePoints(element, app, pointIndices) {
-    const isUncommittedPoint = app.state.editingLinearElement?.lastUncommittedPoint === element.points[element.points.length - 1];
+    const isUncommittedPoint = app.state.selectedLinearElement?.isEditing && app.state.selectedLinearElement?.lastUncommittedPoint === element.points[element.points.length - 1];
     const nextPoints = element.points.filter((_, idx) => {
       return !pointIndices.includes(idx);
     });
@@ -9073,7 +9074,7 @@ var LinearElementEditor = class _LinearElementEditor {
       pointFrom8(origin.x, origin.y),
       pointFrom8(pointerCoords.x, pointerCoords.y)
     );
-    if (!appState.editingLinearElement && dist < DRAGGING_THRESHOLD / appState.zoom.value) {
+    if (!appState.selectedLinearElement?.isEditing && dist < DRAGGING_THRESHOLD / appState.zoom.value) {
       return false;
     }
     return true;
@@ -9826,6 +9827,55 @@ var getNewGroupIdsForDuplication = (groupIds, editingGroupId, mapper) => {
   }
   return copy;
 };
+var getSelectedElementsByGroup = (selectedElements, elementsMap, appState) => {
+  const selectedGroupIds = getSelectedGroupIds(appState);
+  const unboundElements = selectedElements.filter(
+    (element) => !isBoundToContainer(element)
+  );
+  const groups = /* @__PURE__ */ new Map();
+  const elements = /* @__PURE__ */ new Map();
+  const addToElementsMap = (element) => {
+    const currentElementMembers = elements.get(element.id) || [];
+    const boundTextElement = getBoundTextElement(element, elementsMap);
+    if (boundTextElement) {
+      currentElementMembers.push(boundTextElement);
+    }
+    elements.set(element.id, [...currentElementMembers, element]);
+  };
+  const addToGroupsMap = (element, groupId) => {
+    const currentGroupMembers = groups.get(groupId) || [];
+    const boundTextElement = getBoundTextElement(element, elementsMap);
+    if (boundTextElement) {
+      currentGroupMembers.push(boundTextElement);
+    }
+    groups.set(groupId, [...currentGroupMembers, element]);
+  };
+  const handleSingleSelectedGroupCase = (element, selectedGroupId) => {
+    const indexOfSelectedGroupId = element.groupIds.indexOf(selectedGroupId, 0);
+    const nestedGroupCount = element.groupIds.slice(
+      0,
+      indexOfSelectedGroupId
+    ).length;
+    return nestedGroupCount > 0 ? addToGroupsMap(element, element.groupIds[indexOfSelectedGroupId - 1]) : addToElementsMap(element);
+  };
+  const isAllInSameGroup = selectedElements.every(
+    (element) => isSelectedViaGroup(appState, element)
+  );
+  unboundElements.forEach((element) => {
+    const selectedGroupId = getSelectedGroupIdForElement(
+      element,
+      appState.selectedGroupIds
+    );
+    if (!selectedGroupId) {
+      addToElementsMap(element);
+    } else if (selectedGroupIds.length === 1 && isAllInSameGroup) {
+      handleSingleSelectedGroupCase(element, selectedGroupId);
+    } else {
+      addToGroupsMap(element, selectedGroupId);
+    }
+  });
+  return Array.from(groups.values()).concat(Array.from(elements.values()));
+};
 
 // src/selection.ts
 var excludeElementsInFramesFromSelection = (selectedElements) => {
@@ -10513,6 +10563,11 @@ var getCanvasPadding = (element) => {
       return element.strokeWidth * 12;
     case "text":
       return element.fontSize / 2;
+    case "arrow":
+      if (element.endArrowhead || element.endArrowhead) {
+        return 40;
+      }
+      return 20;
     default:
       return 20;
   }
@@ -12742,11 +12797,11 @@ var getNormalizedDimensions = (element) => {
 
 // src/align.ts
 init_define_import_meta_env();
-var alignElements = (selectedElements, alignment, scene) => {
-  const elementsMap = scene.getNonDeletedElementsMap();
-  const groups = getMaximumGroups(
+var alignElements = (selectedElements, alignment, scene, appState) => {
+  const groups = getSelectedElementsByGroup(
     selectedElements,
-    elementsMap
+    scene.getNonDeletedElementsMap(),
+    appState
   );
   const selectionBoundingBox = getCommonBoundingBox(selectedElements);
   return groups.flatMap((group) => {
@@ -13182,8 +13237,9 @@ var Store = class {
   constructor(app) {
     this.app = app;
   }
-  // internally used by history
+  // for internal use by history
   onDurableIncrementEmitter = new Emitter();
+  // for public use as part of onIncrement API
   onStoreIncrementEmitter = new Emitter();
   scheduledMacroActions = /* @__PURE__ */ new Set();
   scheduledMicroActions = [];
@@ -13477,10 +13533,20 @@ var StoreDelta = class {
    */
   static load({
     id,
-    elements: { added, removed, updated }
+    elements: { added, removed, updated },
+    appState: { delta: appStateDelta }
   }) {
     const elements = ElementsDelta.create(added, removed, updated);
-    return new this(id, elements, AppStateDelta.empty());
+    const appState = AppStateDelta.create(appStateDelta);
+    return new this(id, elements, appState);
+  }
+  /**
+   * Squash the passed delta into the current instance.
+   */
+  squash(delta) {
+    this.elements.squash(delta.elements);
+    this.appState.squash(delta.appState);
+    return this;
   }
   /**
    * Inverse store delta, creates new instance of `StoreDelta`.
@@ -13491,8 +13557,12 @@ var StoreDelta = class {
   /**
    * Apply the delta to the passed elements and appState, does not modify the snapshot.
    */
-  static applyTo(delta, elements, appState) {
-    const [nextElements, elementsContainVisibleChange] = delta.elements.applyTo(elements);
+  static applyTo(delta, elements, appState, options) {
+    const [nextElements, elementsContainVisibleChange] = delta.elements.applyTo(
+      elements,
+      StoreSnapshot.empty().elements,
+      options
+    );
     const [nextAppState, appStateContainsVisibleChange] = delta.appState.applyTo(appState, nextElements);
     const appliedVisibleChanges = elementsContainVisibleChange || appStateContainsVisibleChange;
     return [nextElements, nextAppState, appliedVisibleChanges];
@@ -13753,8 +13823,7 @@ var getDefaultObservedAppState = () => {
     viewBackgroundColor: COLOR_PALETTE2.white,
     selectedElementIds: {},
     selectedGroupIds: {},
-    editingLinearElementId: null,
-    selectedLinearElementId: null,
+    selectedLinearElement: null,
     croppingElementId: null,
     activeLockedId: null,
     lockedMultiSelections: {}
@@ -13770,10 +13839,10 @@ var getObservedAppState = (appState) => {
     croppingElementId: appState.croppingElementId,
     activeLockedId: appState.activeLockedId,
     lockedMultiSelections: appState.lockedMultiSelections,
-    editingLinearElementId: appState.editingLinearElement?.elementId ?? // prefer app state, as it's likely newer
-    appState.editingLinearElementId ?? // fallback to observed app state, as it's likely older coming from a previous snapshot
-    null,
-    selectedLinearElementId: appState.selectedLinearElement?.elementId ?? appState.selectedLinearElementId ?? null
+    selectedLinearElement: appState.selectedLinearElement ? {
+      elementId: appState.selectedLinearElement.elementId,
+      isEditing: !!appState.selectedLinearElement.isEditing
+    } : null
   };
   Reflect.defineProperty(observedAppState, hiddenObservedAppStateProp, {
     value: true,
@@ -14337,9 +14406,9 @@ var Scene = class {
   getFramesIncludingDeleted() {
     return this.frames;
   }
-  constructor(elements = null) {
+  constructor(elements = null, options) {
     if (elements) {
-      this.replaceAllElements(elements);
+      this.replaceAllElements(elements, options);
     }
   }
   getSelectedElements(opts) {
@@ -14404,10 +14473,12 @@ var Scene = class {
     }
     return didChange;
   }
-  replaceAllElements(nextElements) {
+  replaceAllElements(nextElements, options) {
     const _nextElements = toArray(nextElements);
     const nextFrameLikes = [];
-    validateIndicesThrottled(_nextElements);
+    if (!options?.skipValidation) {
+      validateIndicesThrottled(_nextElements);
+    }
     this.elements = syncInvalidIndices2(_nextElements);
     this.elementsMap.clear();
     this.elements.forEach((element) => {
@@ -14577,12 +14648,21 @@ var Delta = class _Delta {
   static isEmpty(delta) {
     return !Object.keys(delta.deleted).length && !Object.keys(delta.inserted).length;
   }
+  /**
+   * Merges two deltas into a new one.
+   */
+  static merge(delta1, delta2, delta3) {
+    return _Delta.create(
+      { ...delta1.deleted, ...delta2.deleted, ...delta3?.deleted ?? {} },
+      { ...delta1.inserted, ...delta2.inserted, ...delta3?.inserted ?? {} }
+    );
+  }
   /**
    * Merges deleted and inserted object partials.
    */
   static mergeObjects(prev, added, removed) {
     const cloned = { ...prev };
-    for (const key of Object.keys(removed)) {
+    for (const key of Object.keys(removed ?? {})) {
       delete cloned[key];
     }
     return { ...cloned, ...added };
@@ -14801,6 +14881,9 @@ var AppStateDelta = class _AppStateDelta {
   constructor(delta) {
     this.delta = delta;
   }
+  static create(delta) {
+    return new _AppStateDelta(delta);
+  }
   static calculate(prevAppState, nextAppState) {
     const delta = Delta.calculate(
       prevAppState,
@@ -14822,50 +14905,71 @@ var AppStateDelta = class _AppStateDelta {
     const inversedDelta = Delta.create(this.delta.inserted, this.delta.deleted);
     return new _AppStateDelta(inversedDelta);
   }
+  squash(delta) {
+    const mergedDeletedSelectedElementIds = Delta.mergeObjects(
+      this.delta.deleted.selectedElementIds ?? {},
+      delta.delta.deleted.selectedElementIds ?? {}
+    );
+    const mergedInsertedSelectedElementIds = Delta.mergeObjects(
+      this.delta.inserted.selectedElementIds ?? {},
+      delta.delta.inserted.selectedElementIds ?? {}
+    );
+    const mergedInsertedSelectedGroupIds = Delta.mergeObjects(
+      this.delta.inserted.selectedGroupIds ?? {},
+      delta.delta.inserted.selectedGroupIds ?? {}
+    );
+    const mergedDeletedSelectedGroupIds = Delta.mergeObjects(
+      this.delta.deleted.selectedGroupIds ?? {},
+      delta.delta.deleted.selectedGroupIds ?? {}
+    );
+    const mergedDelta = Delta.create(
+      {
+        selectedElementIds: mergedDeletedSelectedElementIds,
+        selectedGroupIds: mergedDeletedSelectedGroupIds
+      },
+      {
+        selectedElementIds: mergedInsertedSelectedElementIds,
+        selectedGroupIds: mergedInsertedSelectedGroupIds
+      }
+    );
+    this.delta = Delta.merge(this.delta, delta.delta, mergedDelta);
+    return this;
+  }
   applyTo(appState, nextElements) {
     try {
       const {
-        selectedElementIds: removedSelectedElementIds = {},
-        selectedGroupIds: removedSelectedGroupIds = {}
+        selectedElementIds: deletedSelectedElementIds = {},
+        selectedGroupIds: deletedSelectedGroupIds = {}
       } = this.delta.deleted;
       const {
-        selectedElementIds: addedSelectedElementIds = {},
-        selectedGroupIds: addedSelectedGroupIds = {},
-        selectedLinearElementId,
-        editingLinearElementId,
+        selectedElementIds: insertedSelectedElementIds = {},
+        selectedGroupIds: insertedSelectedGroupIds = {},
+        selectedLinearElement: insertedSelectedLinearElement,
         ...directlyApplicablePartial
       } = this.delta.inserted;
       const mergedSelectedElementIds = Delta.mergeObjects(
         appState.selectedElementIds,
-        addedSelectedElementIds,
-        removedSelectedElementIds
+        insertedSelectedElementIds,
+        deletedSelectedElementIds
       );
       const mergedSelectedGroupIds = Delta.mergeObjects(
         appState.selectedGroupIds,
-        addedSelectedGroupIds,
-        removedSelectedGroupIds
+        insertedSelectedGroupIds,
+        deletedSelectedGroupIds
       );
-      const selectedLinearElement = selectedLinearElementId && nextElements.has(selectedLinearElementId) ? new LinearElementEditor(
+      const selectedLinearElement = insertedSelectedLinearElement && nextElements.has(insertedSelectedLinearElement.elementId) ? new LinearElementEditor(
         nextElements.get(
-          selectedLinearElementId
+          insertedSelectedLinearElement.elementId
         ),
-        nextElements
-      ) : null;
-      const editingLinearElement = editingLinearElementId && nextElements.has(editingLinearElementId) ? new LinearElementEditor(
-        nextElements.get(
-          editingLinearElementId
-        ),
-        nextElements
+        nextElements,
+        insertedSelectedLinearElement.isEditing
       ) : null;
       const nextAppState = {
         ...appState,
         ...directlyApplicablePartial,
         selectedElementIds: mergedSelectedElementIds,
         selectedGroupIds: mergedSelectedGroupIds,
-        selectedLinearElement: typeof selectedLinearElementId !== "undefined" ? selectedLinearElement : appState.selectedLinearElement,
-        // otherwise assign what we had before
-        editingLinearElement: typeof editingLinearElementId !== "undefined" ? editingLinearElement : appState.editingLinearElement
-        // otherwise assign what we had before
+        selectedLinearElement: typeof insertedSelectedLinearElement !== "undefined" ? selectedLinearElement : appState.selectedLinearElement
       };
       const constainsVisibleChanges = this.filterInvisibleChanges(
         appState,
@@ -14955,57 +15059,44 @@ var AppStateDelta = class _AppStateDelta {
               nextAppState[key] = null;
             }
             break;
-          case "selectedLinearElementId":
-          case "editingLinearElementId":
-            const appStateKey = _AppStateDelta.convertToAppStateKey(key);
-            const linearElement = nextAppState[appStateKey];
-            if (!linearElement) {
+          case "selectedLinearElement":
+            const nextLinearElement = nextAppState[key];
+            if (!nextLinearElement) {
               visibleDifferenceFlag.value = true;
             } else {
-              const element = nextElements.get(linearElement.elementId);
+              const element = nextElements.get(nextLinearElement.elementId);
               if (element && !element.isDeleted) {
                 visibleDifferenceFlag.value = true;
               } else {
-                nextAppState[appStateKey] = null;
+                nextAppState[key] = null;
               }
             }
             break;
-          case "lockedMultiSelections": {
+          case "lockedMultiSelections":
             const prevLockedUnits = prevAppState[key] || {};
             const nextLockedUnits = nextAppState[key] || {};
             if (!isShallowEqual2(prevLockedUnits, nextLockedUnits)) {
               visibleDifferenceFlag.value = true;
             }
             break;
-          }
-          case "activeLockedId": {
+          case "activeLockedId":
             const prevHitLockedId = prevAppState[key] || null;
             const nextHitLockedId = nextAppState[key] || null;
             if (prevHitLockedId !== nextHitLockedId) {
               visibleDifferenceFlag.value = true;
             }
             break;
-          }
-          default: {
+          default:
             assertNever4(
               key,
               `Unknown ObservedElementsAppState's key "${key}"`,
               true
             );
-          }
         }
       }
     }
     return visibleDifferenceFlag.value;
   }
-  static convertToAppStateKey(key) {
-    switch (key) {
-      case "selectedLinearElementId":
-        return "selectedLinearElement";
-      case "editingLinearElementId":
-        return "editingLinearElement";
-    }
-  }
   static filterSelectedElements(selectedElementIds, elements, visibleDifferenceFlag) {
     const ids = Object.keys(selectedElementIds);
     if (!ids.length) {
@@ -15044,8 +15135,7 @@ var AppStateDelta = class _AppStateDelta {
       editingGroupId,
       selectedGroupIds,
       selectedElementIds,
-      editingLinearElementId,
-      selectedLinearElementId,
+      selectedLinearElement,
       croppingElementId,
       lockedMultiSelections,
       activeLockedId,
@@ -15170,9 +15260,13 @@ var ElementsDelta = class _ElementsDelta {
   Number.isInteger(deleted.version) && Number.isInteger(inserted.version) && // versions should be positive, zero included
   deleted.version >= 0 && inserted.version >= 0 && // versions should never be the same
   deleted.version !== inserted.version);
+  static satisfiesUniqueInvariants = (elementsDelta, id) => {
+    const { added, removed, updated } = elementsDelta;
+    return [added[id], removed[id], updated[id]].filter(Boolean).length === 1;
+  };
   static validate(elementsDelta, type, satifiesSpecialInvariants) {
     for (const [id, delta] of Object.entries(elementsDelta[type])) {
-      if (!this.satisfiesCommmonInvariants(delta) || !satifiesSpecialInvariants(delta)) {
+      if (!this.satisfiesCommmonInvariants(delta) || !this.satisfiesUniqueInvariants(elementsDelta, id) || !satifiesSpecialInvariants(delta)) {
         console.error(
           `Broken invariant for "${type}" delta, element "${id}", delta:`,
           delta
@@ -15199,7 +15293,7 @@ var ElementsDelta = class _ElementsDelta {
     for (const prevElement of prevElements.values()) {
       const nextElement = nextElements.get(prevElement.id);
       if (!nextElement) {
-        const deleted = { ...prevElement, isDeleted: false };
+        const deleted = { ...prevElement };
         const inserted = {
           isDeleted: true,
           version: prevElement.version + 1,
@@ -15210,7 +15304,9 @@ var ElementsDelta = class _ElementsDelta {
           inserted,
           _ElementsDelta.stripIrrelevantProps
         );
-        removed[prevElement.id] = delta;
+        if (!prevElement.isDeleted) {
+          removed[prevElement.id] = delta;
+        }
       }
     }
     for (const nextElement of nextElements.values()) {
@@ -15222,15 +15318,16 @@ var ElementsDelta = class _ElementsDelta {
           versionNonce: randomInteger4()
         };
         const inserted = {
-          ...nextElement,
-          isDeleted: false
+          ...nextElement
         };
         const delta = Delta.create(
           deleted,
           inserted,
           _ElementsDelta.stripIrrelevantProps
         );
-        added[nextElement.id] = delta;
+        if (!nextElement.isDeleted) {
+          added[nextElement.id] = delta;
+        }
         continue;
       }
       if (prevElement.versionNonce !== nextElement.versionNonce) {
@@ -15251,7 +15348,11 @@ var ElementsDelta = class _ElementsDelta {
           }
           continue;
         }
-        if (!Delta.isEmpty(delta)) {
+        const strippedDeleted = _ElementsDelta.stripVersionProps(delta.deleted);
+        const strippedInserted = _ElementsDelta.stripVersionProps(
+          delta.inserted
+        );
+        if (Delta.isInnerDifferent(strippedDeleted, strippedInserted, true)) {
           updated[nextElement.id] = delta;
         }
       }
@@ -15264,8 +15365,8 @@ var ElementsDelta = class _ElementsDelta {
   inverse() {
     const inverseInternal = (deltas) => {
       const inversedDeltas = {};
-      for (const [id, delta] of Object.entries(deltas)) {
-        inversedDeltas[id] = Delta.create(delta.inserted, delta.deleted);
+      for (const [id, { inserted, deleted }] of Object.entries(deltas)) {
+        inversedDeltas[id] = Delta.create({ ...inserted }, { ...deleted });
       }
       return inversedDeltas;
     };
@@ -15329,7 +15430,13 @@ var ElementsDelta = class _ElementsDelta {
         } else {
           latestDelta = delta;
         }
-        if (Delta.isInnerDifferent(latestDelta.deleted, latestDelta.inserted)) {
+        const strippedDeleted = _ElementsDelta.stripVersionProps(
+          latestDelta.deleted
+        );
+        const strippedInserted = _ElementsDelta.stripVersionProps(
+          latestDelta.inserted
+        );
+        if (Delta.isInnerDifferent(strippedDeleted, strippedInserted)) {
           modifiedDeltas[id] = latestDelta;
         }
       }
@@ -15343,26 +15450,30 @@ var ElementsDelta = class _ElementsDelta {
       // redistribute the deltas as `isDeleted` could have been updated
     });
   }
-  applyTo(elements, snapshot = StoreSnapshot.empty().elements, options = {
-    excludedProperties: /* @__PURE__ */ new Set()
-  }) {
+  applyTo(elements, snapshot = StoreSnapshot.empty().elements, options) {
     let nextElements = new Map(elements);
     let changedElements;
     const flags = {
       containsVisibleDifference: false,
-      containsZindexDifference: false
+      containsZindexDifference: false,
+      applyDirection: void 0
     };
     try {
       const applyDeltas = _ElementsDelta.createApplier(
+        elements,
         nextElements,
         snapshot,
-        options,
-        flags
+        flags,
+        options
       );
       const addedElements = applyDeltas(this.added);
       const removedElements = applyDeltas(this.removed);
       const updatedElements = applyDeltas(this.updated);
-      const affectedElements = this.resolveConflicts(elements, nextElements);
+      const affectedElements = this.resolveConflicts(
+        elements,
+        nextElements,
+        flags.applyDirection
+      );
       changedElements = new Map([
         ...addedElements,
         ...removedElements,
@@ -15382,9 +15493,7 @@ var ElementsDelta = class _ElementsDelta {
         changedElements,
         flags
       );
-      const tempScene = new Scene(nextElements);
-      _ElementsDelta.redrawTextBoundingBoxes(tempScene, changedElements);
-      _ElementsDelta.redrawBoundArrows(tempScene, changedElements);
+      _ElementsDelta.redrawElements(nextElements, changedElements);
     } catch (e) {
       console.error(
         `Couldn't mutate elements after applying elements change`,
@@ -15397,7 +15506,76 @@ var ElementsDelta = class _ElementsDelta {
       return [nextElements, flags.containsVisibleDifference];
     }
   }
-  static createApplier = (nextElements, snapshot, options, flags) => (deltas) => {
+  squash(delta) {
+    const { added, removed, updated } = delta;
+    const mergeBoundElements = (prevDelta, nextDelta) => {
+      const mergedDeletedBoundElements = Delta.mergeArrays(
+        prevDelta.deleted.boundElements ?? [],
+        nextDelta.deleted.boundElements ?? [],
+        void 0,
+        (x) => x.id
+      ) ?? [];
+      const mergedInsertedBoundElements = Delta.mergeArrays(
+        prevDelta.inserted.boundElements ?? [],
+        nextDelta.inserted.boundElements ?? [],
+        void 0,
+        (x) => x.id
+      ) ?? [];
+      return Delta.create(
+        {
+          boundElements: mergedDeletedBoundElements
+        },
+        {
+          boundElements: mergedInsertedBoundElements
+        }
+      );
+    };
+    for (const [id, nextDelta] of Object.entries(added)) {
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
+      if (!prevDelta) {
+        this.added[id] = nextDelta;
+      } else {
+        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        delete this.removed[id];
+        delete this.updated[id];
+        this.added[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
+      }
+    }
+    for (const [id, nextDelta] of Object.entries(removed)) {
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
+      if (!prevDelta) {
+        this.removed[id] = nextDelta;
+      } else {
+        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        delete this.added[id];
+        delete this.updated[id];
+        this.removed[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
+      }
+    }
+    for (const [id, nextDelta] of Object.entries(updated)) {
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
+      if (!prevDelta) {
+        this.updated[id] = nextDelta;
+      } else {
+        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        const updatedDelta = Delta.merge(prevDelta, nextDelta, mergedDelta);
+        if (prevDelta === this.added[id]) {
+          this.added[id] = updatedDelta;
+        } else if (prevDelta === this.removed[id]) {
+          this.removed[id] = updatedDelta;
+        } else {
+          this.updated[id] = updatedDelta;
+        }
+      }
+    }
+    if (isTestEnv8() || isDevEnv7()) {
+      _ElementsDelta.validate(this, "added", _ElementsDelta.satisfiesAddition);
+      _ElementsDelta.validate(this, "removed", _ElementsDelta.satisfiesRemoval);
+      _ElementsDelta.validate(this, "updated", _ElementsDelta.satisfiesUpdate);
+    }
+    return this;
+  }
+  static createApplier = (prevElements, nextElements, snapshot, flags, options) => (deltas) => {
     const getElement = _ElementsDelta.createGetter(
       nextElements,
       snapshot,
@@ -15406,14 +15584,20 @@ var ElementsDelta = class _ElementsDelta {
     return Object.entries(deltas).reduce((acc, [id, delta]) => {
       const element = getElement(id, delta.inserted);
       if (element) {
-        const newElement2 = _ElementsDelta.applyDelta(
+        const nextElement = _ElementsDelta.applyDelta(
           element,
           delta,
-          options,
-          flags
+          flags,
+          options
         );
-        nextElements.set(newElement2.id, newElement2);
-        acc.set(newElement2.id, newElement2);
+        nextElements.set(nextElement.id, nextElement);
+        acc.set(nextElement.id, nextElement);
+        if (!flags.applyDirection) {
+          const prevElement = prevElements.get(id);
+          if (prevElement) {
+            flags.applyDirection = prevElement.version > nextElement.version ? "backward" : "forward";
+          }
+        }
       }
       return acc;
     }, /* @__PURE__ */ new Map());
@@ -15438,13 +15622,13 @@ var ElementsDelta = class _ElementsDelta {
     }
     return element;
   };
-  static applyDelta(element, delta, options, flags) {
+  static applyDelta(element, delta, flags, options) {
     const directlyApplicablePartial = {};
     for (const key of Object.keys(delta.inserted)) {
       if (key === "boundElements") {
         continue;
       }
-      if (options.excludedProperties.has(key)) {
+      if (options?.excludedProperties?.has(key)) {
         continue;
       }
       const value = delta.inserted[key];
@@ -15472,7 +15656,7 @@ var ElementsDelta = class _ElementsDelta {
     if (!flags.containsZindexDifference) {
       flags.containsZindexDifference = delta.deleted.index !== delta.inserted.index;
     }
-    return newElementWith(element, directlyApplicablePartial);
+    return newElementWith(element, directlyApplicablePartial, true);
   }
   /**
    * Check for visible changes regardless of whether they were removed, added or updated.
@@ -15497,25 +15681,32 @@ var ElementsDelta = class _ElementsDelta {
    *
    * @returns all elements affected by the conflict resolution
    */
-  resolveConflicts(prevElements, nextElements) {
+  resolveConflicts(prevElements, nextElements, applyDirection = "forward") {
     const nextAffectedElements = /* @__PURE__ */ new Map();
     const updater = (element, updates) => {
       const nextElement = nextElements.get(element.id);
       if (!nextElement) {
         return;
       }
+      const prevElement = prevElements.get(element.id);
+      const nextVersion = applyDirection === "forward" ? nextElement.version + 1 : nextElement.version - 1;
+      const elementUpdates = updates;
       let affectedElement;
-      if (prevElements.get(element.id) === nextElement) {
+      if (prevElement === nextElement) {
         affectedElement = newElementWith(
           nextElement,
-          updates
+          {
+            ...elementUpdates,
+            version: nextVersion
+          },
+          true
         );
       } else {
-        affectedElement = mutateElement(
-          nextElement,
-          nextElements,
-          updates
-        );
+        affectedElement = mutateElement(nextElement, nextElements, {
+          ...elementUpdates,
+          // don't modify the version further, if it's already different
+          version: prevElement?.version !== nextElement.version ? nextElement.version : nextVersion
+        });
       }
       nextAffectedElements.set(affectedElement.id, affectedElement);
       nextElements.set(affectedElement.id, affectedElement);
@@ -15540,19 +15731,10 @@ var ElementsDelta = class _ElementsDelta {
     const prevAffectedElements = new Map(
       Array.from(prevElements).filter(([id]) => nextAffectedElements.has(id))
     );
-    const { added, removed, updated } = _ElementsDelta.calculate(
-      prevAffectedElements,
-      nextAffectedElements
+    this.squash(
+      // technically we could do better here if perf. would become an issue
+      _ElementsDelta.calculate(prevAffectedElements, nextAffectedElements)
     );
-    for (const [id, delta] of Object.entries(added)) {
-      this.added[id] = delta;
-    }
-    for (const [id, delta] of Object.entries(removed)) {
-      this.removed[id] = delta;
-    }
-    for (const [id, delta] of Object.entries(updated)) {
-      this.updated[id] = delta;
-    }
     return nextAffectedElements;
   }
   /**
@@ -15587,6 +15769,20 @@ var ElementsDelta = class _ElementsDelta {
     );
     BindableElement.rebindAffected(nextElements, nextElement(), updater);
   }
+  static redrawElements(nextElements, changedElements) {
+    try {
+      const tempScene = new Scene(nextElements, { skipValidation: true });
+      _ElementsDelta.redrawTextBoundingBoxes(tempScene, changedElements);
+      _ElementsDelta.redrawBoundArrows(tempScene, changedElements);
+    } catch (e) {
+      console.error(`Couldn't redraw elements`, e);
+      if (isTestEnv8() || isDevEnv7()) {
+        throw e;
+      }
+    } finally {
+      return nextElements;
+    }
+  }
   static redrawTextBoundingBoxes(scene, changed) {
     const elements = scene.getNonDeletedElementsMap();
     const boxesToRedraw = /* @__PURE__ */ new Map();
@@ -15675,14 +15871,22 @@ var ElementsDelta = class _ElementsDelta {
     const { id, updated, ...strippedPartial } = partial;
     return strippedPartial;
   }
+  static stripVersionProps(partial) {
+    const { version, versionNonce, ...strippedPartial } = partial;
+    return strippedPartial;
+  }
 };
 
 // src/distribute.ts
 init_define_import_meta_env();
-var distributeElements = (selectedElements, elementsMap, distribution) => {
+var distributeElements = (selectedElements, elementsMap, distribution, appState) => {
   const [start, mid, end, extent] = distribution.axis === "x" ? ["minX", "midX", "maxX", "width"] : ["minY", "midY", "maxY", "height"];
   const bounds = getCommonBoundingBox(selectedElements);
-  const groups = getMaximumGroups(selectedElements, elementsMap).map((group) => [group, getCommonBoundingBox(group)]).sort((a2, b2) => a2[1][mid] - b2[1][mid]);
+  const groups = getSelectedElementsByGroup(
+    selectedElements,
+    elementsMap,
+    appState
+  ).map((group) => [group, getCommonBoundingBox(group)]).sort((a2, b2) => a2[1][mid] - b2[1][mid]);
   let span = 0;
   for (const group of groups) {
     span += group[1][extent];
@@ -16325,7 +16529,7 @@ var newImageElement = (opts) => {
 
 // src/embeddable.ts
 var embeddedLinkCache = /* @__PURE__ */ new Map();
-var RE_YOUTUBE = /^(?:http(?:s)?:\/\/)?(?:www\.)?youtu(?:be\.com|\.be)\/(embed\/|watch\?v=|shorts\/|playlist\?list=|embed\/videoseries\?list=)?([a-zA-Z0-9_-]+)(?:\?t=|&t=|\?start=|&start=)?([a-zA-Z0-9_-]+)?[^\s]*$/;
+var RE_YOUTUBE = /^(?:http(?:s)?:\/\/)?(?:www\.)?youtu(?:be\.com|\.be)\/(embed\/|watch\?v=|shorts\/|playlist\?list=|embed\/videoseries\?list=)?([a-zA-Z0-9_-]+)/;
 var RE_VIMEO = /^(?:http(?:s)?:\/\/)?(?:(?:w){3}\.)?(?:player\.)?vimeo\.com\/(?:video\/)?([^?\s]+)(?:\?.*)?$/;
 var RE_FIGMA = /^https:\/\/(?:www\.)?figma\.com/;
 var RE_GH_GIST = /^https:\/\/gist\.github\.com\/([\w_-]+)\/([\w_-]+)/;
@@ -16338,6 +16542,28 @@ var RE_GENERIC_EMBED = /^<(?:iframe|blockquote)[\s\S]*?\s(?:src|href)=["']([^"']
 var RE_GIPHY = /giphy.com\/(?:clips|embed|gifs)\/[a-zA-Z0-9]*?-?([a-zA-Z0-9]+)(?:[^a-zA-Z0-9]|$)/;
 var RE_REDDIT = /^(?:http(?:s)?:\/\/)?(?:www\.)?reddit\.com\/r\/([a-zA-Z0-9_]+)\/comments\/([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)\/?(?:\?[^#\s]*)?(?:#[^\s]*)?$/;
 var RE_REDDIT_EMBED = /^<blockquote[\s\S]*?\shref=["'](https?:\/\/(?:www\.)?reddit\.com\/[^"']*)/i;
+var parseYouTubeTimestamp = (url) => {
+  let timeParam;
+  try {
+    const urlObj = new URL(url.startsWith("http") ? url : `https://${url}`);
+    timeParam = urlObj.searchParams.get("t") || urlObj.searchParams.get("start");
+  } catch (error) {
+    const timeMatch2 = url.match(/[?&#](?:t|start)=([^&#\s]+)/);
+    timeParam = timeMatch2?.[1];
+  }
+  if (!timeParam) {
+    return 0;
+  }
+  if (/^\d+$/.test(timeParam)) {
+    return parseInt(timeParam, 10);
+  }
+  const timeMatch = timeParam.match(/^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/);
+  if (!timeMatch) {
+    return 0;
+  }
+  const [, hours = "0", minutes = "0", seconds = "0"] = timeMatch;
+  return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);
+};
 var ALLOWED_DOMAINS = /* @__PURE__ */ new Set([
   "youtube.com",
   "youtu.be",
@@ -16386,7 +16612,8 @@ var getEmbedLink = (link) => {
   let aspectRatio = { w: 560, h: 840 };
   const ytLink = link.match(RE_YOUTUBE);
   if (ytLink?.[2]) {
-    const time = ytLink[3] ? `&start=${ytLink[3]}` : ``;
+    const startTime = parseYouTubeTimestamp(originalLink);
+    const time = startTime > 0 ? `&start=${startTime}` : ``;
     const isPortrait = link.includes("shorts");
     type = "video";
     switch (ytLink[1]) {
@@ -18371,7 +18598,7 @@ var getTransformHandles = (element, zoom, elementsMap, pointerType = "mouse", om
   );
 };
 var shouldShowBoundingBox = (elements, appState) => {
-  if (appState.editingLinearElement) {
+  if (appState.selectedLinearElement?.isEditing) {
     return false;
   }
   if (elements.length > 1) {
@@ -19119,6 +19346,7 @@ export {
   getRootElements,
   getSceneVersion,
   getSelectedElements,
+  getSelectedElementsByGroup,
   getSelectedGroupForElement,
   getSelectedGroupIdForElement,
   getSelectedGroupIds,