bpmn-js 16.3.2 → 16.4.0

package/dist/bpmn-modeler.development.js

@@ -1,5 +1,5 @@
 /*!
- * bpmn-js - bpmn-modeler v16.3.2
+ * bpmn-js - bpmn-modeler v16.4.0
  *
  * Copyright (c) 2014-present, camunda Services GmbH
  *
@@ -8,7 +8,7 @@
  *
  * Source Code: https://github.com/bpmn-io/bpmn-js
  *
- * Date: 2024-01-09
+ * Date: 2024-01-23
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -17839,7 +17839,7 @@
    *
    * @return {boolean}
    */
-  function isHorizontal$4(element) {
+  function isHorizontal$3(element) {
 
     if (!is$1(element, 'bpmn:Participant') && !is$1(element, 'bpmn:Lane')) {
       return undefined;
@@ -19392,7 +19392,7 @@
     }
 
     function renderLaneLabel(parentGfx, text, element, attrs = {}) {
-      var isHorizontalLane = isHorizontal$4(element);
+      var isHorizontalLane = isHorizontal$3(element);
 
       var textBox = renderLabel(parentGfx, text, {
         box: {
@@ -20126,7 +20126,7 @@
         var participant = renderLane(parentGfx, element, attrs);
 
         var expandedParticipant = isExpanded(element);
-        var horizontalParticipant = isHorizontal$4(element);
+        var horizontalParticipant = isHorizontal$3(element);
 
         var semantic = getBusinessObject(element),
             name = semantic.get('name');
@@ -38550,16 +38550,18 @@
         trblResize = getTRBLResize(shape, newBounds),
         resizeNeeded = [];
 
+    var isHorizontalLane = isHorizontal$3(shape);
+
     allLanes.forEach(function(other) {
 
       if (other === shape) {
         return;
       }
 
-      var topResize = 0,
-          rightResize = trblResize.right,
-          bottomResize = 0,
-          leftResize = trblResize.left;
+      var topResize = isHorizontalLane ? 0 : trblResize.top,
+          rightResize = isHorizontalLane ? trblResize.right : 0,
+          bottomResize = isHorizontalLane ? 0 : trblResize.bottom,
+          leftResize = isHorizontalLane ? trblResize.left : 0;
 
       var otherTrbl = asTRBL(other);
 
@@ -38573,6 +38575,16 @@
         }
       }
 
+      if (trblResize.left) {
+        if (abs$4(otherTrbl.right - shapeTrbl.left) < 10) {
+          rightResize = shapeNewTrbl.left - otherTrbl.right;
+        }
+
+        if (abs$4(otherTrbl.left - shapeTrbl.left) < 5) {
+          leftResize = shapeNewTrbl.left - otherTrbl.left;
+        }
+      }
+
       if (trblResize.bottom) {
         if (abs$4(otherTrbl.top - shapeTrbl.bottom) < 10) {
           topResize = shapeNewTrbl.bottom - otherTrbl.top;
@@ -38583,6 +38595,16 @@
         }
       }
 
+      if (trblResize.right) {
+        if (abs$4(otherTrbl.left - shapeTrbl.right) < 10) {
+          leftResize = shapeNewTrbl.right - otherTrbl.left;
+        }
+
+        if (abs$4(otherTrbl.right - shapeTrbl.right) < 5) {
+          rightResize = shapeNewTrbl.right - otherTrbl.right;
+        }
+      }
+
       if (topResize || rightResize || bottomResize || leftResize) {
 
         resizeNeeded.push({
@@ -38621,18 +38643,29 @@
 
 
     function compensateLaneDelete(shape, oldParent) {
+      var isHorizontalLane = isHorizontal$3(shape);
 
       var siblings = getChildLanes(oldParent);
 
       var topAffected = [];
       var bottomAffected = [];
+      var leftAffected = [];
+      var rightAffected = [];
 
       eachElement(siblings, function(element) {
 
-        if (element.y > shape.y) {
-          bottomAffected.push(element);
+        if (isHorizontalLane) {
+          if (element.y > shape.y) {
+            bottomAffected.push(element);
+          } else {
+            topAffected.push(element);
+          }
         } else {
-          topAffected.push(element);
+          if (element.x > shape.x) {
+            rightAffected.push(element);
+          } else {
+            leftAffected.push(element);
+          }
         }
 
         return element.children;
@@ -38644,14 +38677,24 @@
 
       var offset;
 
-      if (bottomAffected.length && topAffected.length) {
-        offset = shape.height / 2;
+      if (isHorizontalLane) {
+        if (bottomAffected.length && topAffected.length) {
+          offset = shape.height / 2;
+        } else {
+          offset = shape.height;
+        }
       } else {
-        offset = shape.height;
+        if (rightAffected.length && leftAffected.length) {
+          offset = shape.width / 2;
+        } else {
+          offset = shape.width;
+        }
       }
 
       var topAdjustments,
-          bottomAdjustments;
+          bottomAdjustments,
+          leftAdjustments,
+          rightAdjustments;
 
       if (topAffected.length) {
         topAdjustments = spaceTool.calculateAdjustments(
@@ -38672,6 +38715,26 @@
           bottomAdjustments.resizingShapes,
           { x: 0, y: -offset }, 'n');
       }
+
+      if (leftAffected.length) {
+        leftAdjustments = spaceTool.calculateAdjustments(
+          leftAffected, 'x', offset, shape.x - 10);
+
+        spaceTool.makeSpace(
+          leftAdjustments.movingShapes,
+          leftAdjustments.resizingShapes,
+          { x: offset, y: 0 }, 'e');
+      }
+
+      if (rightAffected.length) {
+        rightAdjustments = spaceTool.calculateAdjustments(
+          rightAffected, 'x', -offset, shape.x + shape.width + 10);
+
+        spaceTool.makeSpace(
+          rightAdjustments.movingShapes,
+          rightAdjustments.resizingShapes,
+          { x: -offset, y: 0 }, 'w');
+      }
     }
 
 
@@ -39152,7 +39215,7 @@
 
       // ensure bpmn:Group and label elements are dropped
       // always onto the root
-      if (hover !== rootElement && (shape.labelTarget || is$1(shape, 'bpmn:Group'))) {
+      if (hover !== rootElement && (shape.labelTarget || isAny(shape, [ 'bpmn:Group', 'bpmn:TextAnnotation' ]))) {
         event.hover = rootElement;
         event.hoverGfx = elementRegistry.getGraphics(event.hover);
       }
@@ -41650,203 +41713,252 @@
     'selection'
   ];
 
-  var HIGH_PRIORITY$e = 1500;
-
-  /**
-   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
-   *
-   * @typedef {import('../../../model/Types').Shape} Shape
-   *
-   * @typedef {import('diagram-js/lib/util/Types').Dimensions} Dimensions
-   * @typedef {import('diagram-js/lib/util/Types').Direction} Direction
-   * @typedef {import('diagram-js/lib/util/Types').RectTRBL} RectTRBL
-   */
-
-  /**
-   * @type {Dimensions}
-   */
-  var GROUP_MIN_DIMENSIONS = { width: 140, height: 120 };
-
-  /**
-   * @type {Dimensions}
-   */
-  var LANE_MIN_DIMENSIONS = { width: 300, height: 60 };
-
-  /**
-   * @type {Dimensions}
-   */
-  var PARTICIPANT_MIN_DIMENSIONS = { width: 300, height: 150 };
-
-  /**
-   * @type {Dimensions}
-   */
-  var SUB_PROCESS_MIN_DIMENSIONS = { width: 140, height: 120 };
-
-  /**
-   * @type {Dimensions}
-   */
-  var TEXT_ANNOTATION_MIN_DIMENSIONS = { width: 50, height: 30 };
-
-  /**
-   * Set minimum bounds/resize constraints on resize.
-   *
-   * @param {EventBus} eventBus
-   */
-  function ResizeBehavior$1(eventBus) {
-    eventBus.on('resize.start', HIGH_PRIORITY$e, function(event) {
-      var context = event.context,
-          shape = context.shape,
-          direction = context.direction,
-          balanced = context.balanced;
-
-      if (is$1(shape, 'bpmn:Lane') || is$1(shape, 'bpmn:Participant')) {
-        context.resizeConstraints = getParticipantResizeConstraints(shape, direction, balanced);
-      }
-
-      if (is$1(shape, 'bpmn:Participant')) {
-        context.minDimensions = PARTICIPANT_MIN_DIMENSIONS;
-      }
-
-      if (is$1(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
-        context.minDimensions = SUB_PROCESS_MIN_DIMENSIONS;
-      }
-
-      if (is$1(shape, 'bpmn:TextAnnotation')) {
-        context.minDimensions = TEXT_ANNOTATION_MIN_DIMENSIONS;
-      }
-    });
-  }
-
-  ResizeBehavior$1.$inject = [ 'eventBus' ];
-
-
-  var abs$2 = Math.abs,
-      min$1 = Math.min,
-      max$3 = Math.max;
-
-
-  function addToTrbl(trbl, attr, value, choice) {
-    var current = trbl[attr];
-
-    // make sure to set the value if it does not exist
-    // or apply the correct value by comparing against
-    // choice(value, currentValue)
-    trbl[attr] = current === undefined ? value : choice(value, current);
-  }
-
-  function addMin(trbl, attr, value) {
-    return addToTrbl(trbl, attr, value, min$1);
-  }
-
-  function addMax(trbl, attr, value) {
-    return addToTrbl(trbl, attr, value, max$3);
-  }
-
-  var LANE_RIGHT_PADDING = 20,
-      LANE_LEFT_PADDING = 50,
-      LANE_TOP_PADDING = 20,
-      LANE_BOTTOM_PADDING = 20;
-
-  /**
-   * @param {Shape} laneShape
-   * @param {Direction} resizeDirection
-   * @param {boolean} [balanced=false]
-   *
-   * @return { {
-   *   min: RectTRBL;
-   *   max: RectTRBL;
-   * } }
-   */
-  function getParticipantResizeConstraints(laneShape, resizeDirection, balanced) {
-    var lanesRoot = getLanesRoot(laneShape);
-
-    var isFirst = true,
-        isLast = true;
-
-    // max top/bottom size for lanes
-    var allLanes = collectLanes(lanesRoot, [ lanesRoot ]);
-
-    var laneTrbl = asTRBL(laneShape);
-
-    var maxTrbl = {},
-        minTrbl = {};
-
-    if (/e/.test(resizeDirection)) {
-      minTrbl.right = laneTrbl.left + LANE_MIN_DIMENSIONS.width;
-    } else
-    if (/w/.test(resizeDirection)) {
-      minTrbl.left = laneTrbl.right - LANE_MIN_DIMENSIONS.width;
-    }
-
-    allLanes.forEach(function(other) {
-
-      var otherTrbl = asTRBL(other);
-
-      if (/n/.test(resizeDirection)) {
-
-        if (otherTrbl.top < (laneTrbl.top - 10)) {
-          isFirst = false;
-        }
-
-        // max top size (based on next element)
-        if (balanced && abs$2(laneTrbl.top - otherTrbl.bottom) < 10) {
-          addMax(maxTrbl, 'top', otherTrbl.top + LANE_MIN_DIMENSIONS.height);
-        }
-
-        // min top size (based on self or nested element)
-        if (abs$2(laneTrbl.top - otherTrbl.top) < 5) {
-          addMin(minTrbl, 'top', otherTrbl.bottom - LANE_MIN_DIMENSIONS.height);
-        }
-      }
-
-      if (/s/.test(resizeDirection)) {
-
-        if (otherTrbl.bottom > (laneTrbl.bottom + 10)) {
-          isLast = false;
-        }
-
-        // max bottom size (based on previous element)
-        if (balanced && abs$2(laneTrbl.bottom - otherTrbl.top) < 10) {
-          addMin(maxTrbl, 'bottom', otherTrbl.bottom - LANE_MIN_DIMENSIONS.height);
-        }
-
-        // min bottom size (based on self or nested element)
-        if (abs$2(laneTrbl.bottom - otherTrbl.bottom) < 5) {
-          addMax(minTrbl, 'bottom', otherTrbl.top + LANE_MIN_DIMENSIONS.height);
-        }
-      }
-    });
-
-    // max top/bottom/left/right size based on flow nodes
-    var flowElements = lanesRoot.children.filter(function(s) {
-      return !s.hidden && !s.waypoints && (is$1(s, 'bpmn:FlowElement') || is$1(s, 'bpmn:Artifact'));
-    });
-
-    flowElements.forEach(function(flowElement) {
-
-      var flowElementTrbl = asTRBL(flowElement);
-
-      if (isFirst && /n/.test(resizeDirection)) {
-        addMin(minTrbl, 'top', flowElementTrbl.top - LANE_TOP_PADDING);
-      }
-
-      if (/e/.test(resizeDirection)) {
-        addMax(minTrbl, 'right', flowElementTrbl.right + LANE_RIGHT_PADDING);
-      }
-
-      if (isLast && /s/.test(resizeDirection)) {
-        addMax(minTrbl, 'bottom', flowElementTrbl.bottom + LANE_BOTTOM_PADDING);
-      }
-
-      if (/w/.test(resizeDirection)) {
-        addMin(minTrbl, 'left', flowElementTrbl.left - LANE_LEFT_PADDING);
-      }
-    });
-
-    return {
-      min: minTrbl,
-      max: maxTrbl
-    };
+  var HIGH_PRIORITY$e = 1500;
+
+  /**
+   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+   *
+   * @typedef {import('../../../model/Types').Shape} Shape
+   *
+   * @typedef {import('diagram-js/lib/util/Types').Dimensions} Dimensions
+   * @typedef {import('diagram-js/lib/util/Types').Direction} Direction
+   * @typedef {import('diagram-js/lib/util/Types').RectTRBL} RectTRBL
+   */
+
+  /**
+   * @type {Dimensions}
+   */
+  var GROUP_MIN_DIMENSIONS = { width: 140, height: 120 };
+
+  /**
+   * @type {Dimensions}
+   */
+  var LANE_MIN_DIMENSIONS = { width: 300, height: 60 };
+
+  /**
+   * @type {Dimensions}
+   */
+  var VERTICAL_LANE_MIN_DIMENSIONS = { width: 60, height: 300 };
+
+  /**
+   * @type {Dimensions}
+   */
+  var PARTICIPANT_MIN_DIMENSIONS = { width: 300, height: 150 };
+
+  /**
+   * @type {Dimensions}
+   */
+  var VERTICAL_PARTICIPANT_MIN_DIMENSIONS = { width: 150, height: 300 };
+
+  /**
+   * @type {Dimensions}
+   */
+  var SUB_PROCESS_MIN_DIMENSIONS = { width: 140, height: 120 };
+
+  /**
+   * @type {Dimensions}
+   */
+  var TEXT_ANNOTATION_MIN_DIMENSIONS = { width: 50, height: 30 };
+
+  /**
+   * Set minimum bounds/resize constraints on resize.
+   *
+   * @param {EventBus} eventBus
+   */
+  function ResizeBehavior$1(eventBus) {
+    eventBus.on('resize.start', HIGH_PRIORITY$e, function(event) {
+      var context = event.context,
+          shape = context.shape,
+          direction = context.direction,
+          balanced = context.balanced;
+
+      if (is$1(shape, 'bpmn:Lane') || is$1(shape, 'bpmn:Participant')) {
+        context.resizeConstraints = getParticipantResizeConstraints(shape, direction, balanced);
+      }
+
+      if (is$1(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
+        context.minDimensions = SUB_PROCESS_MIN_DIMENSIONS;
+      }
+
+      if (is$1(shape, 'bpmn:TextAnnotation')) {
+        context.minDimensions = TEXT_ANNOTATION_MIN_DIMENSIONS;
+      }
+    });
+  }
+
+  ResizeBehavior$1.$inject = [ 'eventBus' ];
+
+
+  var abs$2 = Math.abs,
+      min$1 = Math.min,
+      max$3 = Math.max;
+
+
+  function addToTrbl(trbl, attr, value, choice) {
+    var current = trbl[attr];
+
+    // make sure to set the value if it does not exist
+    // or apply the correct value by comparing against
+    // choice(value, currentValue)
+    trbl[attr] = current === undefined ? value : choice(value, current);
+  }
+
+  function addMin(trbl, attr, value) {
+    return addToTrbl(trbl, attr, value, min$1);
+  }
+
+  function addMax(trbl, attr, value) {
+    return addToTrbl(trbl, attr, value, max$3);
+  }
+
+  var LANE_PADDING = { top: 20, left: 50, right: 20, bottom: 20 },
+      VERTICAL_LANE_PADDING = { top: 50, left: 20, right: 20, bottom: 20 };
+
+  /**
+   * @param {Shape} laneShape
+   * @param {Direction} resizeDirection
+   * @param {boolean} [balanced=false]
+   *
+   * @return { {
+   *   min: RectTRBL;
+   *   max: RectTRBL;
+   * } }
+   */
+  function getParticipantResizeConstraints(laneShape, resizeDirection, balanced) {
+    var lanesRoot = getLanesRoot(laneShape);
+
+    var isFirst = true,
+        isLast = true;
+
+    var allLanes = collectLanes(lanesRoot, [ lanesRoot ]);
+
+    var laneTrbl = asTRBL(laneShape);
+
+    var maxTrbl = {},
+        minTrbl = {};
+
+    var isHorizontalLane = isHorizontal$3(laneShape);
+
+    var minDimensions = isHorizontalLane ? LANE_MIN_DIMENSIONS : VERTICAL_LANE_MIN_DIMENSIONS;
+
+    if (/n/.test(resizeDirection)) {
+      minTrbl.top = laneTrbl.bottom - minDimensions.height;
+    } else
+    if (/e/.test(resizeDirection)) {
+      minTrbl.right = laneTrbl.left + minDimensions.width;
+    } else
+    if (/s/.test(resizeDirection)) {
+      minTrbl.bottom = laneTrbl.top + minDimensions.height;
+    } else
+    if (/w/.test(resizeDirection)) {
+      minTrbl.left = laneTrbl.right - minDimensions.width;
+    }
+
+    // min/max size based on related lanes
+    allLanes.forEach(function(other) {
+
+      var otherTrbl = asTRBL(other);
+
+      if (/n/.test(resizeDirection)) {
+        if (isHorizontalLane && otherTrbl.top < (laneTrbl.top - 10)) {
+          isFirst = false;
+        }
+
+        // max top size (based on next element)
+        if (balanced && abs$2(laneTrbl.top - otherTrbl.bottom) < 10) {
+          addMax(maxTrbl, 'top', otherTrbl.top + minDimensions.height);
+        }
+
+        // min top size (based on self or nested element)
+        if (abs$2(laneTrbl.top - otherTrbl.top) < 5) {
+          addMin(minTrbl, 'top', otherTrbl.bottom - minDimensions.height);
+        }
+      }
+
+      if (/e/.test(resizeDirection)) {
+
+        if (!isHorizontalLane && otherTrbl.right > (laneTrbl.right + 10)) {
+          isLast = false;
+        }
+
+        // max right size (based on previous element)
+        if (balanced && abs$2(laneTrbl.right - otherTrbl.left) < 10) {
+          addMin(maxTrbl, 'right', otherTrbl.right - minDimensions.width);
+        }
+
+        // min right size (based on self or nested element)
+        if (abs$2(laneTrbl.right - otherTrbl.right) < 5) {
+          addMax(minTrbl, 'right', otherTrbl.left + minDimensions.width);
+        }
+      }
+
+      if (/s/.test(resizeDirection)) {
+
+        if (isHorizontalLane && otherTrbl.bottom > (laneTrbl.bottom + 10)) {
+          isLast = false;
+        }
+
+        // max bottom size (based on previous element)
+        if (balanced && abs$2(laneTrbl.bottom - otherTrbl.top) < 10) {
+          addMin(maxTrbl, 'bottom', otherTrbl.bottom - minDimensions.height);
+        }
+
+        // min bottom size (based on self or nested element)
+        if (abs$2(laneTrbl.bottom - otherTrbl.bottom) < 5) {
+          addMax(minTrbl, 'bottom', otherTrbl.top + minDimensions.height);
+        }
+      }
+
+      if (/w/.test(resizeDirection)) {
+
+        if (!isHorizontalLane && otherTrbl.left < (laneTrbl.left - 10)) {
+          isFirst = false;
+        }
+
+        // max left size (based on next element)
+        if (balanced && abs$2(laneTrbl.left - otherTrbl.right) < 10) {
+          addMax(maxTrbl, 'left', otherTrbl.left + minDimensions.width);
+        }
+
+        // min left size (based on self or nested element)
+        if (abs$2(laneTrbl.left - otherTrbl.left) < 5) {
+          addMin(minTrbl, 'left', otherTrbl.right - minDimensions.width);
+        }
+      }
+    });
+
+    // max top/bottom/left/right size based on flow nodes
+    var flowElements = lanesRoot.children.filter(function(s) {
+      return !s.hidden && !s.waypoints && (is$1(s, 'bpmn:FlowElement') || is$1(s, 'bpmn:Artifact'));
+    });
+
+    var padding = isHorizontalLane ? LANE_PADDING : VERTICAL_LANE_PADDING;
+
+    flowElements.forEach(function(flowElement) {
+
+      var flowElementTrbl = asTRBL(flowElement);
+
+      if (isFirst && /n/.test(resizeDirection)) {
+        addMin(minTrbl, 'top', flowElementTrbl.top - padding.top);
+      }
+
+      if (isLast && /e/.test(resizeDirection)) {
+        addMax(minTrbl, 'right', flowElementTrbl.right + padding.right);
+      }
+
+      if (isLast && /s/.test(resizeDirection)) {
+        addMax(minTrbl, 'bottom', flowElementTrbl.bottom + padding.bottom);
+      }
+
+      if (isFirst && /w/.test(resizeDirection)) {
+        addMin(minTrbl, 'left', flowElementTrbl.left - padding.left);
+      }
+    });
+
+    return {
+      min: minTrbl,
+      max: maxTrbl
+    };
   }
 
   /**
@@ -42097,128 +42209,191 @@
     });
   }
 
-  /**
-   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
-   *
-   * @typedef {import('../../../model/Types').Shape} Shape
-   */
-
-  var max$2 = Math.max;
-
-  /**
-   * @param {EventBus} eventBus
-   */
-  function SpaceToolBehavior$1(eventBus) {
-    eventBus.on('spaceTool.getMinDimensions', function(context) {
-      var shapes = context.shapes,
-          axis = context.axis,
-          start = context.start,
-          minDimensions = {};
-
-      forEach$1(shapes, function(shape) {
-        var id = shape.id;
-
-        if (is$1(shape, 'bpmn:Participant')) {
-
-          if (isHorizontal$3(axis)) {
-            minDimensions[ id ] = PARTICIPANT_MIN_DIMENSIONS;
-          } else {
-            minDimensions[ id ] = {
-              width: PARTICIPANT_MIN_DIMENSIONS.width,
-              height: getParticipantMinHeight(shape, start)
-            };
-          }
-
-        }
-
-        if (is$1(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
-          minDimensions[ id ] = SUB_PROCESS_MIN_DIMENSIONS;
-        }
-
-        if (is$1(shape, 'bpmn:TextAnnotation')) {
-          minDimensions[ id ] = TEXT_ANNOTATION_MIN_DIMENSIONS;
-        }
-
-        if (is$1(shape, 'bpmn:Group')) {
-          minDimensions[ id ] = GROUP_MIN_DIMENSIONS;
-        }
-      });
-
-      return minDimensions;
-    });
-  }
-
-  SpaceToolBehavior$1.$inject = [ 'eventBus' ];
-
-
-  // helpers //////////
-  function isHorizontal$3(axis) {
-    return axis === 'x';
-  }
-
-  /**
-   * Get minimum height for participant taking lanes into account.
-   *
-   * @param {Shape} participant
-   * @param {number} start
-   *
-   * @return {number}
-   */
-  function getParticipantMinHeight(participant, start) {
-    var lanesMinHeight;
-
-    if (!hasChildLanes(participant)) {
-      return PARTICIPANT_MIN_DIMENSIONS.height;
-    }
-
-    lanesMinHeight = getLanesMinHeight(participant, start);
-
-    return max$2(PARTICIPANT_MIN_DIMENSIONS.height, lanesMinHeight);
-  }
-
-  function hasChildLanes(element) {
-    return !!getChildLanes(element).length;
-  }
-
-  function getLanesMinHeight(participant, resizeStart) {
-    var lanes = getChildLanes(participant),
-        resizedLane;
-
-    // find the nested lane which is currently resized
-    resizedLane = findResizedLane(lanes, resizeStart);
-
-    // resized lane cannot shrink below the minimum height
-    // but remaining lanes' dimensions are kept intact
-    return participant.height - resizedLane.height + LANE_MIN_DIMENSIONS.height;
-  }
-
-  /**
-   * Find nested lane which is currently resized.
-   *
-   * @param {Shape[]} lanes
-   * @param {number} resizeStart
-   *
-   * @return {Shape}
-   */
-  function findResizedLane(lanes, resizeStart) {
-    var i, lane, childLanes;
-
-    for (i = 0; i < lanes.length; i++) {
-      lane = lanes[i];
-
-      // resizing current lane or a lane nested
-      if (resizeStart >= lane.y && resizeStart <= lane.y + lane.height) {
-        childLanes = getChildLanes(lane);
-
-        // a nested lane is resized
-        if (childLanes.length) {
-          return findResizedLane(childLanes, resizeStart);
-        }
-
-        // current lane is the resized one
-        return lane;
-      }
-    }
+  /**
+   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+   *
+   * @typedef {import('../../../model/Types').Shape} Shape
+   */
+
+  var max$2 = Math.max;
+
+  /**
+   * @param {EventBus} eventBus
+   */
+  function SpaceToolBehavior$1(eventBus) {
+    eventBus.on('spaceTool.getMinDimensions', function(context) {
+      var shapes = context.shapes,
+          axis = context.axis,
+          start = context.start,
+          minDimensions = {};
+
+      forEach$1(shapes, function(shape) {
+        var id = shape.id;
+
+        if (is$1(shape, 'bpmn:Participant')) {
+          minDimensions[ id ] = getParticipantMinDimensions(shape, axis, start);
+        }
+
+        if (is$1(shape, 'bpmn:Lane')) {
+          minDimensions[ id ] = isHorizontal$3(shape) ? LANE_MIN_DIMENSIONS : VERTICAL_LANE_MIN_DIMENSIONS;
+        }
+
+        if (is$1(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
+          minDimensions[ id ] = SUB_PROCESS_MIN_DIMENSIONS;
+        }
+
+        if (is$1(shape, 'bpmn:TextAnnotation')) {
+          minDimensions[ id ] = TEXT_ANNOTATION_MIN_DIMENSIONS;
+        }
+
+        if (is$1(shape, 'bpmn:Group')) {
+          minDimensions[ id ] = GROUP_MIN_DIMENSIONS;
+        }
+      });
+
+      return minDimensions;
+    });
+  }
+
+  SpaceToolBehavior$1.$inject = [ 'eventBus' ];
+
+
+  // helpers //////////
+  function isHorizontalAxis(axis) {
+    return axis === 'x';
+  }
+
+  /**
+   * Get minimum dimensions for participant taking lanes into account.
+   *
+   * @param {Shape} participant
+   * @param {Axis} axis
+   * @param {number} start
+   *
+   * @return {number}
+   */
+  function getParticipantMinDimensions(participant, axis, start) {
+    var isHorizontalLane = isHorizontal$3(participant);
+
+    if (!hasChildLanes(participant)) {
+      return isHorizontalLane ? PARTICIPANT_MIN_DIMENSIONS : VERTICAL_PARTICIPANT_MIN_DIMENSIONS;
+    }
+
+    var isHorizontalResize = isHorizontalAxis(axis);
+    var minDimensions = {};
+
+    if (isHorizontalResize) {
+      if (isHorizontalLane) {
+        minDimensions = PARTICIPANT_MIN_DIMENSIONS;
+      } else {
+        minDimensions = {
+          width: getParticipantMinWidth(participant, start, isHorizontalResize),
+          height: VERTICAL_PARTICIPANT_MIN_DIMENSIONS.height
+        };
+      }
+
+    } else {
+      if (isHorizontalLane) {
+        minDimensions = {
+          width: PARTICIPANT_MIN_DIMENSIONS.width,
+          height: getParticipantMinHeight(participant, start, isHorizontalResize)
+        };
+      } else {
+        minDimensions = VERTICAL_PARTICIPANT_MIN_DIMENSIONS;
+      }
+    }
+
+    return minDimensions;
+  }
+
+  /**
+   * Get minimum height for participant taking lanes into account.
+   *
+   * @param {Shape} participant
+   * @param {number} start
+   * @param {boolean} isHorizontalResize
+   *
+   * @return {number}
+   */
+  function getParticipantMinHeight(participant, start, isHorizontalResize) {
+    var lanesMinHeight;
+    lanesMinHeight = getLanesMinHeight(participant, start, isHorizontalResize);
+    return max$2(PARTICIPANT_MIN_DIMENSIONS.height, lanesMinHeight);
+  }
+
+  /**
+   * Get minimum width for participant taking lanes into account.
+   *
+   * @param {Shape} participant
+   * @param {number} start
+   * @param {boolean} isHorizontalResize
+   *
+   * @return {number}
+   */
+  function getParticipantMinWidth(participant, start, isHorizontalResize) {
+    var lanesMinWidth;
+    lanesMinWidth = getLanesMinWidth(participant, start, isHorizontalResize);
+    return max$2(VERTICAL_PARTICIPANT_MIN_DIMENSIONS.width, lanesMinWidth);
+  }
+
+  function hasChildLanes(element) {
+    return !!getChildLanes(element).length;
+  }
+
+  function getLanesMinHeight(participant, resizeStart, isHorizontalResize) {
+    var lanes = getChildLanes(participant),
+        resizedLane;
+
+    // find the nested lane which is currently resized
+    resizedLane = findResizedLane(lanes, resizeStart, isHorizontalResize);
+
+    // resized lane cannot shrink below the minimum height
+    // but remaining lanes' dimensions are kept intact
+    return participant.height - resizedLane.height + LANE_MIN_DIMENSIONS.height;
+  }
+
+  function getLanesMinWidth(participant, resizeStart, isHorizontalResize) {
+    var lanes = getChildLanes(participant),
+        resizedLane;
+
+    // find the nested lane which is currently resized
+    resizedLane = findResizedLane(lanes, resizeStart, isHorizontalResize);
+
+    // resized lane cannot shrink below the minimum width
+    // but remaining lanes' dimensions are kept intact
+    return participant.width - resizedLane.width + VERTICAL_LANE_MIN_DIMENSIONS.width;
+  }
+
+  /**
+   * Find nested lane which is currently resized.
+   *
+   * @param {Shape[]} lanes
+   * @param {number} resizeStart
+   * @param {boolean} isHorizontalResize
+   *
+   * @return {Shape}
+   */
+  function findResizedLane(lanes, resizeStart, isHorizontalResize) {
+    var i, lane, childLanes;
+
+    for (i = 0; i < lanes.length; i++) {
+      lane = lanes[i];
+
+      // resizing current lane or a lane nested
+      if (!isHorizontalResize && resizeStart >= lane.y && resizeStart <= lane.y + lane.height ||
+          isHorizontalResize && resizeStart >= lane.x && resizeStart <= lane.x + lane.width) {
+
+        childLanes = getChildLanes(lane);
+
+        // a nested lane is resized
+        if (childLanes.length) {
+          return findResizedLane(childLanes, resizeStart, isHorizontalResize);
+        }
+
+        // current lane is the resized one
+        return lane;
+      }
+    }
   }
 
   /**
@@ -42837,6 +43012,44 @@
     };
   }
 
+  /**
+   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+   */
+
+  function TextAnnotationBehavior(eventBus) {
+
+    CommandInterceptor.call(this, eventBus);
+
+    // On Append, TextAnnotations will be created on the Root.
+    // The default for connections will create the connection in the parent of
+    // the source element, so we overwrite the parent here.
+    this.preExecute('connection.create', function(context) {
+      const { target } = context;
+
+      if (!is$1(target, 'bpmn:TextAnnotation')) {
+        return;
+      }
+
+      context.parent = target.parent;
+    }, true);
+
+    this.preExecute([ 'shape.create', 'shape.resize', 'elements.move' ], function(context) {
+      const shapes = context.shapes || [ context.shape ];
+
+      if (shapes.length === 1 && is$1(shapes[0], 'bpmn:TextAnnotation')) {
+        context.hints = context.hints || {};
+
+        context.hints.autoResize = false;
+      }
+    }, true);
+  }
+
+  e$2(TextAnnotationBehavior, CommandInterceptor);
+
+  TextAnnotationBehavior.$inject = [
+    'eventBus'
+  ];
+
   /**
    * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
    * @typedef {import('../Modeling').default} Modeling
@@ -43357,6 +43570,7 @@
       'spaceToolBehavior',
       'subProcessPlaneBehavior',
       'subProcessStartEventBehavior',
+      'textAnnotationBehavior',
       'toggleCollapseConnectionBehaviour',
       'toggleElementCollapseBehaviour',
       'unclaimIdBehavior',
@@ -43397,6 +43611,7 @@
     spaceToolBehavior: [ 'type', SpaceToolBehavior$1 ],
     subProcessPlaneBehavior: [ 'type', SubProcessPlaneBehavior ],
     subProcessStartEventBehavior: [ 'type', SubProcessStartEventBehavior ],
+    textAnnotationBehavior: [ 'type', TextAnnotationBehavior ],
     toggleCollapseConnectionBehaviour: [ 'type', ToggleCollapseConnectionBehaviour ],
     toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
     unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],
@@ -44373,11 +44588,11 @@
     }
 
     if (is$1(shape, 'bpmn:Lane')) {
-      return !newBounds || (newBounds.width >= 130 && newBounds.height >= 60);
+      return true;
     }
 
     if (is$1(shape, 'bpmn:Participant')) {
-      return !newBounds || (newBounds.width >= 250 && newBounds.height >= 50);
+      return true;
     }
 
     if (isTextAnnotation(shape)) {
@@ -44774,6 +44989,12 @@
           ]
         }
       },
+      {
+        type: 'bpmn:TextAnnotation',
+        order: {
+          level: 9
+        }
+      },
       {
         type: 'bpmn:MessageFlow', order: {
           level: 9,
@@ -44856,8 +45077,8 @@
 
     this.getOrdering = function(element, newParent) {
 
-      // render labels always on top
-      if (element.labelTarget) {
+      // render labels and text annotations always on top
+      if (element.labelTarget || is$1(element, 'bpmn:TextAnnotation')) {
         return {
           parent: canvas.findRoot(newParent) || canvas.getRootElement(),
           index: -1
@@ -46811,6 +47032,10 @@
 
       newElement.di = {};
 
+      if (type === 'bpmn:ExclusiveGateway') {
+        newElement.di.isMarkerVisible = true;
+      }
+
       // colors will be set to DI
       copyProperties(element.di, newElement.di, [
         'fill',
@@ -48253,15 +48478,18 @@
     // do not resize:
     //
     // * text annotations (horizontally/vertically)
-    // * empty pools (vertically)
+    // * empty horizontal pools (vertically)
+    // * empty vertical pools (horizontally)
     adjustments.resizingShapes = adjustments.resizingShapes.filter(function(shape) {
 
       if (is$1(shape, 'bpmn:TextAnnotation')) {
         return false;
       }
 
-      if (axis === 'y' && isCollapsedPool$1(shape)) {
-        return false;
+      if (isCollapsedPool$1(shape)) {
+        if (axis === 'y' && isHorizontal$3(shape) || axis === 'x' && !isHorizontal$3(shape)) {
+          return false;
+        }
       }
 
       return true;
@@ -49826,7 +50054,7 @@
       const di = getDi(element),
             diLabel = di && di.get('label');
 
-      if (isLabelExternal(element)) {
+      if (isLabelExternal(element) || isPlane(element)) {
         return;
       }
 
@@ -50550,7 +50778,15 @@
     }
 
     if (is$1(businessObject, 'bpmn:ExclusiveGateway')) {
-      di.isMarkerVisible = true;
+      if (has$1(attrs, 'isMarkerVisible')) {
+        if (attrs.isMarkerVisible === undefined) {
+          di.isMarkerVisible = false;
+        } else {
+          attrs = applyAttribute(di, attrs, 'isMarkerVisible');
+        }
+      } else {
+        di.isMarkerVisible = true;
+      }
     }
 
     if (isDefined(attrs.triggeredByEvent)) {
@@ -58895,7 +59131,7 @@
         'delete': {
           group: 'edit',
           className: 'bpmn-icon-trash',
-          title: this._translate('Remove'),
+          title: this._translate('Delete'),
           action: {
             click: function(event, elements) {
               modeling.removeElements(elements.slice());
@@ -59173,7 +59409,8 @@
           'append.gateway': appendAction(
             'bpmn:ExclusiveGateway',
             'bpmn-icon-gateway-none',
-            translate('Append gateway')
+            translate('Append gateway'),
+            { isMarkerVisible: true }
           ),
           'append.append-task': appendAction(
             'bpmn:Task',
@@ -59196,7 +59433,7 @@
         'replace': {
           group: 'edit',
           className: 'bpmn-icon-screw-wrench',
-          title: translate('Change type'),
+          title: translate('Change element'),
           action: {
             click: function(event, element) {
 
@@ -59220,7 +59457,7 @@
         'append.text-annotation': appendAction(
           'bpmn:TextAnnotation',
           'bpmn-icon-text-annotation',
-          translate('Append text annotation')
+          translate('Add text annotation')
         )
       });
     }
@@ -59237,19 +59474,13 @@
         'append.text-annotation': appendAction(
           'bpmn:TextAnnotation',
           'bpmn-icon-text-annotation',
-          translate('Append text annotation')
+          translate('Add text annotation')
         ),
 
         'connect': {
           group: 'connect',
           className: 'bpmn-icon-connection-multi',
-          title: translate(
-            'Connect using ' +
-              (businessObject.isForCompensation
-                ? ''
-                : 'sequence/message flow or ') +
-              'association'
-          ),
+          title: translate('Connect to other element'),
           action: {
             click: startConnect,
             dragstart: startConnect,
@@ -59291,7 +59522,7 @@
         'append.text-annotation': appendAction(
           'bpmn:TextAnnotation',
           'bpmn-icon-text-annotation',
-          translate('Append text annotation')
+          translate('Add text annotation')
         )
       });
     }
@@ -59310,7 +59541,7 @@
         'delete': {
           group: 'edit',
           className: 'bpmn-icon-trash',
-          title: translate('Remove'),
+          title: translate('Delete'),
           action: {
             click: removeElement
           }
@@ -62451,7 +62682,7 @@
 
     // adjust for expanded pools AND lanes
     if (is$1(element, 'bpmn:Lane') || isExpandedPool(element)) {
-      var isHorizontalLane = isHorizontal$4(element);
+      var isHorizontalLane = isHorizontal$3(element);
 
       var laneBounds = isHorizontalLane ? {
         width: bbox.height,
@@ -62479,7 +62710,7 @@
 
     // internal labels for collapsed participants
     if (isCollapsedPool(element)) {
-      var isHorizontalPool = isHorizontal$4(element);
+      var isHorizontalPool = isHorizontal$3(element);
 
       var poolBounds = isHorizontalPool ? {
         width: bbox.width,
@@ -65151,12 +65382,6 @@
 
       function createListener(event) {
         var shape = elementFactory.createShape(assign$1({ type: type }, options));
-
-        if (options) {
-          var di = getDi(shape);
-          di.isExpanded = options.isExpanded;
-        }
-
         create.start(event, shape);
       }
 
@@ -65256,7 +65481,8 @@
       ),
       'create.exclusive-gateway': createAction(
         'bpmn:ExclusiveGateway', 'gateway', 'bpmn-icon-gateway-none',
-        translate('Create gateway')
+        translate('Create gateway'),
+        { isMarkerVisible: true }
       ),
       'create.task': createAction(
         'bpmn:Task', 'activity', 'bpmn-icon-task',