@excalidraw/element 0.18.0-c65b684e9 → 0.18.0-c6f8ef9

package/dist/dev/index.js

@@ -12849,7 +12849,6 @@ import {
   arrayToMap as arrayToMap10,
   arrayToObject,
   assertNever as assertNever4,
-  invariant as invariant8,
   isDevEnv as isDevEnv7,
   isShallowEqual as isShallowEqual2,
   isTestEnv as isTestEnv8,
@@ -13496,7 +13495,7 @@ var EphemeralIncrement = class extends StoreIncrement {
     this.change = change;
   }
 };
-var StoreDelta = class {
+var StoreDelta = class _StoreDelta {
   constructor(id, elements, appState) {
     this.id = id;
     this.elements = elements;
@@ -13534,10 +13533,23 @@ 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 deltas into the aggregated delta instance.
+   */
+  static squash(...deltas) {
+    const aggregatedDelta = _StoreDelta.empty();
+    for (const delta of deltas) {
+      aggregatedDelta.elements.squash(delta.elements);
+      aggregatedDelta.appState.squash(delta.appState);
+    }
+    return aggregatedDelta;
   }
   /**
    * Inverse store delta, creates new instance of `StoreDelta`.
@@ -13548,9 +13560,7 @@ var StoreDelta = class {
   /**
    * Apply the delta to the passed elements and appState, does not modify the snapshot.
    */
-  static applyTo(delta, elements, appState, options = {
-    excludedProperties: /* @__PURE__ */ new Set()
-  }) {
+  static applyTo(delta, elements, appState, options) {
     const [nextElements, elementsContainVisibleChange] = delta.elements.applyTo(
       elements,
       StoreSnapshot.empty().elements,
@@ -13576,6 +13586,9 @@ var StoreDelta = class {
       }
     );
   }
+  static empty() {
+    return _StoreDelta.create(ElementsDelta.empty(), AppStateDelta.empty());
+  }
   isEmpty() {
     return this.elements.isEmpty() && this.appState.isEmpty();
   }
@@ -13816,8 +13829,7 @@ var getDefaultObservedAppState = () => {
     viewBackgroundColor: COLOR_PALETTE2.white,
     selectedElementIds: {},
     selectedGroupIds: {},
-    selectedLinearElementId: null,
-    selectedLinearElementIsEditing: null,
+    selectedLinearElement: null,
     croppingElementId: null,
     activeLockedId: null,
     lockedMultiSelections: {}
@@ -13833,8 +13845,10 @@ var getObservedAppState = (appState) => {
     croppingElementId: appState.croppingElementId,
     activeLockedId: appState.activeLockedId,
     lockedMultiSelections: appState.lockedMultiSelections,
-    selectedLinearElementId: appState.selectedLinearElement?.elementId ?? appState.selectedLinearElementId ?? null,
-    selectedLinearElementIsEditing: appState.selectedLinearElement?.isEditing ?? appState.selectedLinearElementIsEditing ?? null
+    selectedLinearElement: appState.selectedLinearElement ? {
+      elementId: appState.selectedLinearElement.elementId,
+      isEditing: !!appState.selectedLinearElement.isEditing
+    } : null
   };
   Reflect.defineProperty(observedAppState, hiddenObservedAppStateProp, {
     value: true,
@@ -14398,9 +14412,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) {
@@ -14465,10 +14479,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) => {
@@ -14641,16 +14657,16 @@ var Delta = class _Delta {
   /**
    * Merges two deltas into a new one.
    */
-  static merge(delta1, delta2) {
+  static merge(delta1, delta2, delta3 = _Delta.empty()) {
     return _Delta.create(
-      { ...delta1.deleted, ...delta2.deleted },
-      { ...delta1.inserted, ...delta2.inserted }
+      { ...delta1.deleted, ...delta2.deleted, ...delta3.deleted },
+      { ...delta1.inserted, ...delta2.inserted, ...delta3.inserted }
     );
   }
   /**
    * Merges deleted and inserted object partials.
    */
-  static mergeObjects(prev, added, removed) {
+  static mergeObjects(prev, added, removed = {}) {
     const cloned = { ...prev };
     for (const key of Object.keys(removed)) {
       delete cloned[key];
@@ -14871,6 +14887,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,
@@ -14893,65 +14912,97 @@ var AppStateDelta = class _AppStateDelta {
     return new _AppStateDelta(inversedDelta);
   }
   squash(delta) {
-    this.delta = Delta.merge(this.delta, delta.delta);
+    if (delta.isEmpty()) {
+      return this;
+    }
+    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 mergedDeletedSelectedGroupIds = Delta.mergeObjects(
+      this.delta.deleted.selectedGroupIds ?? {},
+      delta.delta.deleted.selectedGroupIds ?? {}
+    );
+    const mergedInsertedSelectedGroupIds = Delta.mergeObjects(
+      this.delta.inserted.selectedGroupIds ?? {},
+      delta.delta.inserted.selectedGroupIds ?? {}
+    );
+    const mergedDeletedLockedMultiSelections = Delta.mergeObjects(
+      this.delta.deleted.lockedMultiSelections ?? {},
+      delta.delta.deleted.lockedMultiSelections ?? {}
+    );
+    const mergedInsertedLockedMultiSelections = Delta.mergeObjects(
+      this.delta.inserted.lockedMultiSelections ?? {},
+      delta.delta.inserted.lockedMultiSelections ?? {}
+    );
+    const mergedInserted = {};
+    const mergedDeleted = {};
+    if (Object.keys(mergedDeletedSelectedElementIds).length || Object.keys(mergedInsertedSelectedElementIds).length) {
+      mergedDeleted.selectedElementIds = mergedDeletedSelectedElementIds;
+      mergedInserted.selectedElementIds = mergedInsertedSelectedElementIds;
+    }
+    if (Object.keys(mergedDeletedSelectedGroupIds).length || Object.keys(mergedInsertedSelectedGroupIds).length) {
+      mergedDeleted.selectedGroupIds = mergedDeletedSelectedGroupIds;
+      mergedInserted.selectedGroupIds = mergedInsertedSelectedGroupIds;
+    }
+    if (Object.keys(mergedDeletedLockedMultiSelections).length || Object.keys(mergedInsertedLockedMultiSelections).length) {
+      mergedDeleted.lockedMultiSelections = mergedDeletedLockedMultiSelections;
+      mergedInserted.lockedMultiSelections = mergedInsertedLockedMultiSelections;
+    }
+    this.delta = Delta.merge(
+      this.delta,
+      delta.delta,
+      Delta.create(mergedDeleted, mergedInserted)
+    );
     return this;
   }
   applyTo(appState, nextElements) {
     try {
       const {
-        selectedElementIds: removedSelectedElementIds = {},
-        selectedGroupIds: removedSelectedGroupIds = {}
+        selectedElementIds: deletedSelectedElementIds = {},
+        selectedGroupIds: deletedSelectedGroupIds = {},
+        lockedMultiSelections: deletedLockedMultiSelections = {}
       } = this.delta.deleted;
       const {
-        selectedElementIds: addedSelectedElementIds = {},
-        selectedGroupIds: addedSelectedGroupIds = {},
-        selectedLinearElementId,
-        selectedLinearElementIsEditing,
+        selectedElementIds: insertedSelectedElementIds = {},
+        selectedGroupIds: insertedSelectedGroupIds = {},
+        lockedMultiSelections: insertedLockedMultiSelections = {},
+        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
       );
-      let selectedLinearElement = appState.selectedLinearElement;
-      if (selectedLinearElementId === null) {
-        selectedLinearElement = null;
-      } else if (selectedLinearElementId && nextElements.has(selectedLinearElementId)) {
-        selectedLinearElement = new LinearElementEditor(
-          nextElements.get(
-            selectedLinearElementId
-          ),
-          nextElements,
-          selectedLinearElementIsEditing === true
-          // Can be unknown which is defaulted to false
-        );
-      }
-      if (
-        // Value being 'null' is equivaluent to unknown in this case because it only gets set
-        // to null when 'selectedLinearElementId' is set to null
-        selectedLinearElementIsEditing != null
-      ) {
-        invariant8(
-          selectedLinearElement,
-          `selectedLinearElement is null when selectedLinearElementIsEditing is set to ${selectedLinearElementIsEditing}`
-        );
-        selectedLinearElement = {
-          ...selectedLinearElement,
-          isEditing: selectedLinearElementIsEditing
-        };
-      }
+      const mergedLockedMultiSelections = Delta.mergeObjects(
+        appState.lockedMultiSelections,
+        insertedLockedMultiSelections,
+        deletedLockedMultiSelections
+      );
+      const selectedLinearElement = insertedSelectedLinearElement && nextElements.has(insertedSelectedLinearElement.elementId) ? new LinearElementEditor(
+        nextElements.get(
+          insertedSelectedLinearElement.elementId
+        ),
+        nextElements,
+        insertedSelectedLinearElement.isEditing
+      ) : null;
       const nextAppState = {
         ...appState,
         ...directlyApplicablePartial,
         selectedElementIds: mergedSelectedElementIds,
         selectedGroupIds: mergedSelectedGroupIds,
-        selectedLinearElement
+        lockedMultiSelections: mergedLockedMultiSelections,
+        selectedLinearElement: typeof insertedSelectedLinearElement !== "undefined" ? selectedLinearElement : appState.selectedLinearElement
       };
       const constainsVisibleChanges = this.filterInvisibleChanges(
         appState,
@@ -15041,63 +15092,44 @@ var AppStateDelta = class _AppStateDelta {
               nextAppState[key] = null;
             }
             break;
-          case "selectedLinearElementId": {
-            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 "selectedLinearElementIsEditing": {
-            const prevIsEditing = prevAppState.selectedLinearElement?.isEditing ?? false;
-            const nextIsEditing = nextAppState.selectedLinearElement?.isEditing ?? false;
-            if (prevIsEditing !== nextIsEditing) {
-              visibleDifferenceFlag.value = true;
-            }
-            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";
-    }
-  }
   static filterSelectedElements(selectedElementIds, elements, visibleDifferenceFlag) {
     const ids = Object.keys(selectedElementIds);
     if (!ids.length) {
@@ -15136,8 +15168,7 @@ var AppStateDelta = class _AppStateDelta {
       editingGroupId,
       selectedGroupIds,
       selectedElementIds,
-      selectedLinearElementId,
-      selectedLinearElementIsEditing,
+      selectedLinearElement,
       croppingElementId,
       lockedMultiSelections,
       activeLockedId,
@@ -15174,12 +15205,6 @@ var AppStateDelta = class _AppStateDelta {
         "lockedMultiSelections",
         (prevValue) => prevValue ?? {}
       );
-      Delta.diffObjects(
-        deleted,
-        inserted,
-        "activeLockedId",
-        (prevValue) => prevValue ?? null
-      );
     } catch (e) {
       console.error(`Couldn't postprocess appstate change deltas.`);
       if (isTestEnv8() || isDevEnv7()) {
@@ -15262,9 +15287,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
@@ -15291,7 +15320,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,
@@ -15302,7 +15331,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()) {
@@ -15314,15 +15345,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) {
@@ -15343,7 +15375,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;
         }
       }
@@ -15421,7 +15457,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;
         }
       }
@@ -15435,26 +15477,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,
@@ -15474,9 +15520,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`,
@@ -15490,34 +15534,81 @@ var ElementsDelta = class _ElementsDelta {
     }
   }
   squash(delta) {
+    if (delta.isEmpty()) {
+      return this;
+    }
     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
+      ) ?? [];
+      if (!mergedDeletedBoundElements.length && !mergedInsertedBoundElements.length) {
+        return;
+      }
+      return Delta.create(
+        {
+          boundElements: mergedDeletedBoundElements
+        },
+        {
+          boundElements: mergedInsertedBoundElements
+        }
+      );
+    };
     for (const [id, nextDelta] of Object.entries(added)) {
-      const prevDelta = this.added[id];
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
       if (!prevDelta) {
         this.added[id] = nextDelta;
       } else {
-        this.added[id] = Delta.merge(prevDelta, nextDelta);
+        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.removed[id];
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
       if (!prevDelta) {
         this.removed[id] = nextDelta;
       } else {
-        this.removed[id] = Delta.merge(prevDelta, nextDelta);
+        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.updated[id];
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
       if (!prevDelta) {
         this.updated[id] = nextDelta;
       } else {
-        this.updated[id] = Delta.merge(prevDelta, nextDelta);
+        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 = (nextElements, snapshot, options, flags) => (deltas) => {
+  static createApplier = (prevElements, nextElements, snapshot, flags, options) => (deltas) => {
     const getElement = _ElementsDelta.createGetter(
       nextElements,
       snapshot,
@@ -15526,14 +15617,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());
@@ -15558,13 +15655,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];
@@ -15592,7 +15689,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.
@@ -15617,25 +15714,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);
@@ -15698,6 +15802,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();
@@ -15786,6 +15904,10 @@ var ElementsDelta = class _ElementsDelta {
     const { id, updated, ...strippedPartial } = partial;
     return strippedPartial;
   }
+  static stripVersionProps(partial) {
+    const { version, versionNonce, ...strippedPartial } = partial;
+    return strippedPartial;
+  }
 };
 
 // src/distribute.ts
@@ -16789,7 +16911,7 @@ var embeddableURLValidator = (url, validateEmbeddable) => {
 
 // src/flowchart.ts
 init_define_import_meta_env();
-import { KEYS as KEYS3, invariant as invariant9, toBrandedType as toBrandedType2 } from "@excalidraw/common";
+import { KEYS as KEYS3, invariant as invariant8, toBrandedType as toBrandedType2 } from "@excalidraw/common";
 import { pointFrom as pointFrom13 } from "@excalidraw/math";
 var VERTICAL_OFFSET = 100;
 var HORIZONTAL_OFFSET = 100;
@@ -16819,7 +16941,7 @@ var getNodeRelatives = (type, node, elementsMap, direction) => {
         if (!relative) {
           return acc;
         }
-        invariant9(
+        invariant8(
           isBindableElement(relative),
           "not an ExcalidrawBindableElement"
         );
@@ -16935,7 +17057,7 @@ var addNewNode = (element, appState, direction, scene) => {
     fillStyle: element.fillStyle,
     strokeStyle: element.strokeStyle
   });
-  invariant9(
+  invariant8(
     isFlowchartNodeElement(nextNode),
     "not an ExcalidrawFlowchartNodeElement"
   );
@@ -16993,7 +17115,7 @@ var addNewNodes = (startNode, appState, direction, scene, numberOfNodes) => {
       fillStyle: startNode.fillStyle,
       strokeStyle: startNode.strokeStyle
     });
-    invariant9(
+    invariant8(
       isFlowchartNodeElement(nextNode),
       "not an ExcalidrawFlowchartNodeElement"
     );
@@ -17219,7 +17341,7 @@ var FlowChartCreator = class {
     }
     if (startNode.frameId) {
       const frame = elementsMap.get(startNode.frameId);
-      invariant9(
+      invariant8(
         frame && isFrameElement(frame),
         "not an ExcalidrawFrameElement"
       );