bpmn-js 10.2.0 → 10.3.0

package/dist/bpmn-modeler.development.js

@@ -1,5 +1,5 @@
 /*!
- * bpmn-js - bpmn-modeler v10.2.0
+ * bpmn-js - bpmn-modeler v10.3.0
  *
  * Copyright (c) 2014-present, camunda Services GmbH
  *
@@ -8,7 +8,7 @@
  *
  * Source Code: https://github.com/bpmn-io/bpmn-js
  *
- * Date: 2022-10-02
+ * Date: 2022-11-11
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -4278,6 +4278,8 @@
 
   var intersect = findPathIntersections;
 
+  var intersectPaths = intersect;
+
   function roundBounds(bounds) {
     return {
       x: Math.round(bounds.x),
@@ -4514,7 +4516,7 @@
 
 
   function getIntersections(a, b) {
-    return intersect(a, b);
+    return intersectPaths(a, b);
   }
 
 
@@ -28699,6 +28701,8 @@
     middle: 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%201800%201800%22%3E%3Cpath%20style%3D%22stroke%3AcurrentColor%3Bstroke-width%3A100%3Bstroke-linecap%3Around%22%20d%3D%22M150%20900h1500%22%2F%3E%3Crect%20x%3D%22150%22%20y%3D%22250%22%20width%3D%22600%22%20height%3D%221300%22%20rx%3D%221%22%20style%3D%22fill%3Anone%3Bstroke%3AcurrentColor%3Bstroke-width%3A100%22%2F%3E%3Crect%20x%3D%221050%22%20y%3D%22500%22%20width%3D%22600%22%20height%3D%22800%22%20rx%3D%221%22%20style%3D%22fill%3AcurrentColor%3Bstroke%3AcurrentColor%3Bstroke-width%3A100%3Bopacity%3A.5%22%2F%3E%3C%2Fsvg%3E'
   };
 
+  var ICONS$1 = icons$1;
+
   var LOW_PRIORITY$l = 900;
 
   /**
@@ -28742,7 +28746,7 @@
       'align-elements': {
         group: 'align-elements',
         title: self._translate('Align elements'),
-        imageUrl: icons$1['align'],
+        imageUrl: ICONS$1['align'],
         action: {
           click: function(event, elements) {
             var position = self._getMenuPosition(elements);
@@ -28836,7 +28840,7 @@
         group: 'align',
         title: translate('Align elements ' + alignment),
         className: 'bjs-align-elements-menu-entry',
-        imageUrl: icons$1[alignment],
+        imageUrl: ICONS$1[alignment],
         action: function(event, entry) {
           alignElements.trigger(elements, alignment);
           popupMenu.close();
@@ -30898,7 +30902,7 @@
 
   function getPathIntersection(waypoints, reference) {
 
-    var intersections = intersect(circlePath(reference, INTERSECTION_THRESHOLD$1), linePath(waypoints));
+    var intersections = intersectPaths(circlePath(reference, INTERSECTION_THRESHOLD$1), linePath(waypoints));
 
     var a = intersections[0],
         b = intersections[intersections.length - 1],
@@ -34897,7 +34901,7 @@
       }
 
       // attachers (priority = 2)
-      if (isAttacher$1(element)) {
+      if (isAttacher$2(element)) {
         descriptor.priority = 2;
 
         descriptor.host = element.host.id;
@@ -35359,7 +35363,7 @@
 
   // helpers //////////
 
-  function isAttacher$1(element) {
+  function isAttacher$2(element) {
     return !!element.host;
   }
 
@@ -38865,6 +38869,8 @@
     vertical: 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%201800%201800%22%3E%3Cpath%20style%3D%22fill%3Anone%3Bstroke%3AcurrentColor%3Bstroke-width%3A100%3Bstroke-linejoin%3Around%22%20d%3D%22M400%201350H150V450h250%22%2F%3E%3Crect%20x%3D%22450%22%20y%3D%22150%22%20width%3D%221200%22%20height%3D%22600%22%20rx%3D%221%22%20style%3D%22fill%3Anone%3Bstroke%3AcurrentColor%3Bstroke-width%3A100%22%2F%3E%3Crect%20x%3D%22450%22%20y%3D%221050%22%20width%3D%22800%22%20height%3D%22600%22%20rx%3D%221%22%20style%3D%22fill%3AcurrentColor%3Bstroke%3AcurrentColor%3Bstroke-width%3A100%3Bopacity%3A.5%22%2F%3E%3C%2Fsvg%3E',
   };
 
+  var ICONS = icons;
+
   var LOW_PRIORITY$g = 900;
 
   /**
@@ -38911,7 +38917,7 @@
         group: 'distribute',
         title: translate('Distribute elements horizontally'),
         className: 'bjs-align-elements-menu-entry',
-        imageUrl: icons['horizontal'],
+        imageUrl: ICONS['horizontal'],
         action: function(event, entry) {
           distributeElements.trigger(elements, 'horizontal');
           popupMenu.close();
@@ -38920,7 +38926,7 @@
       'distribute-elements-vertical': {
         group: 'distribute',
         title: translate('Distribute elements vertically'),
-        imageUrl: icons['vertical'],
+        imageUrl: ICONS['vertical'],
         action: function(event, entry) {
           distributeElements.trigger(elements, 'vertical');
           popupMenu.close();
@@ -43218,62 +43224,75 @@
     CommandInterceptor.call(this, eventBus);
 
     /**
-     * Remove existing sequence flows of event-based target before connecting
-     * from event-based gateway.
+     * Remove incoming sequence flows of event-based target when creating
+     * sequence flow.
+     *
+     * 1. If source is event-based gateway remove all incoming sequence flows
+     * 2. If source is not event-based gateway remove all incoming sequence flows
+     * whose source is event-based gateway
      */
     this.preExecuted('connection.create', function(event) {
-
       var context = event.context,
+          connection = context.connection,
           source = context.source,
           target = context.target,
-          existingIncomingConnections = target.incoming.slice();
+          hints = context.hints;
 
-      if (context.hints && context.hints.createElementsBehavior === false) {
+      if (hints && hints.createElementsBehavior === false) {
         return;
       }
 
-      if (
-        is$1(source, 'bpmn:EventBasedGateway') &&
-        target.incoming.length
-      ) {
+      if (!isSequenceFlow(connection)) {
+        return;
+      }
 
-        existingIncomingConnections.filter(isSequenceFlow)
-          .forEach(function(sequenceFlow) {
-            modeling.removeConnection(sequenceFlow);
-          });
+      var sequenceFlows = [];
+
+      if (is$1(source, 'bpmn:EventBasedGateway')) {
+        sequenceFlows = target.incoming.filter(isSequenceFlow);
+      } else {
+        sequenceFlows = target.incoming.filter(function(connection) {
+          return isSequenceFlow(connection)
+            && is$1(connection.source, 'bpmn:EventBasedGateway');
+        });
       }
+
+      sequenceFlows.forEach(function(sequenceFlow) {
+        modeling.removeConnection(sequenceFlow);
+      });
     });
 
     /**
-     *  After replacing shape with event-based gateway, remove incoming sequence
-     *  flows of event-based targets which do not belong to event-based gateway
-     *  source.
+     * Remove incoming sequence flows of event-based targets when replacing source
+     * with event-based gateway.
      */
     this.preExecuted('shape.replace', function(event) {
-
-      var newShape = event.context.newShape,
-          newShapeTargets,
-          newShapeTargetsIncomingSequenceFlows;
+      var context = event.context,
+          newShape = context.newShape;
 
       if (!is$1(newShape, 'bpmn:EventBasedGateway')) {
         return;
       }
 
-      newShapeTargets = newShape.outgoing.filter(isSequenceFlow)
-        .map(function(sequenceFlow) {
-          return sequenceFlow.target;
-        });
+      var targets = newShape.outgoing.filter(isSequenceFlow)
+        .reduce(function(targets, sequenceFlow) {
+          if (!targets.includes(sequenceFlow.target)) {
+            return targets.concat(sequenceFlow.target);
+          }
 
-      newShapeTargetsIncomingSequenceFlows = newShapeTargets.reduce(function(sequenceFlows, target) {
-        var incomingSequenceFlows = target.incoming.filter(isSequenceFlow);
+          return targets;
+        }, []);
 
-        return sequenceFlows.concat(incomingSequenceFlows);
-      }, []);
+      targets.forEach(function(target) {
+        target.incoming.filter(isSequenceFlow).forEach(function(sequenceFlow) {
+          const sequenceFlowsFromNewShape = target.incoming.filter(isSequenceFlow).filter(function(sequenceFlow) {
+            return sequenceFlow.source === newShape;
+          });
 
-      newShapeTargetsIncomingSequenceFlows.forEach(function(sequenceFlow) {
-        if (sequenceFlow.source !== newShape) {
-          modeling.removeConnection(sequenceFlow);
-        }
+          if (sequenceFlow.source !== newShape || sequenceFlowsFromNewShape.length > 1) {
+            modeling.removeConnection(sequenceFlow);
+          }
+        });
       });
     });
   }
@@ -43285,9 +43304,7 @@
 
   e(EventBasedGatewayBehavior, CommandInterceptor);
 
-
-
-  // helpers //////////////////////
+  // helpers //////////
 
   function isSequenceFlow(connection) {
     return is$1(connection, 'bpmn:SequenceFlow');
@@ -48088,16 +48105,6 @@
   }
 
   function canConnectSequenceFlow(source, target) {
-
-    if (
-      isEventBasedTarget(target) &&
-      target.incoming.length > 0 &&
-      areOutgoingEventBasedGatewayConnections(target.incoming) &&
-      !is$1(source, 'bpmn:EventBasedGateway')
-    ) {
-      return false;
-    }
-
     return isSequenceFlowSource(source) &&
            isSequenceFlowTarget(target) &&
            isSameScope(source, target) &&
@@ -48169,19 +48176,6 @@
     return true;
   }
 
-  function isOutgoingEventBasedGatewayConnection(connection) {
-
-    if (connection && connection.source) {
-      return is$1(connection.source, 'bpmn:EventBasedGateway');
-    }
-  }
-
-  function areOutgoingEventBasedGatewayConnections(connections) {
-    connections = connections || [];
-
-    return connections.some(isOutgoingEventBasedGatewayConnection);
-  }
-
   function getRootElement(element) {
     return getParent(element, 'bpmn:Process') || getParent(element, 'bpmn:Collaboration');
   }
@@ -48498,2407 +48492,2572 @@
     bpmnOrderingProvider: [ 'type', BpmnOrderingProvider ]
   };
 
+  var LOW_PRIORITY$6 = 250;
+
   /**
-   * A service that offers un- and redoable execution of commands.
-   *
-   * The command stack is responsible for executing modeling actions
-   * in a un- and redoable manner. To do this it delegates the actual
-   * command execution to {@link CommandHandler}s.
-   *
-   * Command handlers provide {@link CommandHandler#execute(ctx)} and
-   * {@link CommandHandler#revert(ctx)} methods to un- and redo a command
-   * identified by a command context.
-   *
-   *
-   * ## Life-Cycle events
-   *
-   * In the process the command stack fires a number of life-cycle events
-   * that other components to participate in the command execution.
-   *
-   *    * preExecute
-   *    * preExecuted
-   *    * execute
-   *    * executed
-   *    * postExecute
-   *    * postExecuted
-   *    * revert
-   *    * reverted
-   *
-   * A special event is used for validating, whether a command can be
-   * performed prior to its execution.
-   *
-   *    * canExecute
-   *
-   * Each of the events is fired as `commandStack.{eventName}` and
-   * `commandStack.{commandName}.{eventName}`, respectively. This gives
-   * components fine grained control on where to hook into.
-   *
-   * The event object fired transports `command`, the name of the
-   * command and `context`, the command context.
-   *
-   *
-   * ## Creating Command Handlers
-   *
-   * Command handlers should provide the {@link CommandHandler#execute(ctx)}
-   * and {@link CommandHandler#revert(ctx)} methods to implement
-   * redoing and undoing of a command.
-   *
-   * A command handler _must_ ensure undo is performed properly in order
-   * not to break the undo chain. It must also return the shapes that
-   * got changed during the `execute` and `revert` operations.
-   *
-   * Command handlers may execute other modeling operations (and thus
-   * commands) in their `preExecute` and `postExecute` phases. The command
-   * stack will properly group all commands together into a logical unit
-   * that may be re- and undone atomically.
-   *
-   * Command handlers must not execute other commands from within their
-   * core implementation (`execute`, `revert`).
-   *
-   *
-   * ## Change Tracking
-   *
-   * During the execution of the CommandStack it will keep track of all
-   * elements that have been touched during the command's execution.
-   *
-   * At the end of the CommandStack execution it will notify interested
-   * components via an 'elements.changed' event with all the dirty
-   * elements.
-   *
-   * The event can be picked up by components that are interested in the fact
-   * that elements have been changed. One use case for this is updating
-   * their graphical representation after moving / resizing or deletion.
-   *
-   * @see CommandHandler
+   * The tool manager acts as middle-man between the available tool's and the Palette,
+   * it takes care of making sure that the correct active state is set.
    *
-   * @param {EventBus} eventBus
-   * @param {Injector} injector
+   * @param  {Object}    eventBus
+   * @param  {Object}    dragging
    */
-  function CommandStack(eventBus, injector) {
+  function ToolManager(eventBus, dragging) {
+    this._eventBus = eventBus;
+    this._dragging = dragging;
 
-    /**
-     * A map of all registered command handlers.
-     *
-     * @type {Object}
-     */
-    this._handlerMap = {};
+    this._tools = [];
+    this._active = null;
+  }
 
-    /**
-     * A stack containing all re/undoable actions on the diagram
-     *
-     * @type {Array<Object>}
-     */
-    this._stack = [];
+  ToolManager.$inject = [ 'eventBus', 'dragging' ];
 
-    /**
-     * The current index on the stack
-     *
-     * @type {number}
-     */
-    this._stackIdx = -1;
+  ToolManager.prototype.registerTool = function(name, events) {
+    var tools = this._tools;
 
-    /**
-     * Current active commandStack execution
-     *
-     * @type {Object}
-     * @property {Object[]} actions
-     * @property {Object[]} dirty
-     * @property { 'undo' | 'redo' | 'clear' | 'execute' | null } trigger the cause of the current excecution
-     */
-    this._currentExecution = {
-      actions: [],
-      dirty: [],
-      trigger: null
-    };
+    if (!events) {
+      throw new Error('A tool has to be registered with it\'s "events"');
+    }
 
+    tools.push(name);
 
-    this._injector = injector;
-    this._eventBus = eventBus;
+    this.bindEvents(name, events);
+  };
 
-    this._uid = 1;
+  ToolManager.prototype.isActive = function(tool) {
+    return tool && this._active === tool;
+  };
 
-    eventBus.on([
-      'diagram.destroy',
-      'diagram.clear'
-    ], function() {
-      this.clear(false);
-    }, this);
-  }
+  ToolManager.prototype.length = function(tool) {
+    return this._tools.length;
+  };
 
-  CommandStack.$inject = [ 'eventBus', 'injector' ];
+  ToolManager.prototype.setActive = function(tool) {
+    var eventBus = this._eventBus;
 
+    if (this._active !== tool) {
+      this._active = tool;
 
-  /**
-   * Execute a command
-   *
-   * @param {string} command the command to execute
-   * @param {Object} context the environment to execute the command in
-   */
-  CommandStack.prototype.execute = function(command, context) {
-    if (!command) {
-      throw new Error('command required');
+      eventBus.fire('tool-manager.update', { tool: tool });
     }
+  };
 
-    this._currentExecution.trigger = 'execute';
+  ToolManager.prototype.bindEvents = function(name, events) {
+    var eventBus = this._eventBus,
+        dragging = this._dragging;
 
-    const action = { command: command, context: context };
+    var eventsToRegister = [];
 
-    this._pushAction(action);
-    this._internalExecute(action);
-    this._popAction(action);
-  };
+    eventBus.on(events.tool + '.init', function(event) {
+      var context = event.context;
 
+      // Active tools that want to reactivate themselves must do this explicitly
+      if (!context.reactivate && this.isActive(name)) {
+        this.setActive(null);
 
-  /**
-   * Ask whether a given command can be executed.
-   *
-   * Implementors may hook into the mechanism on two ways:
-   *
-   *   * in event listeners:
-   *
-   *     Users may prevent the execution via an event listener.
-   *     It must prevent the default action for `commandStack.(<command>.)canExecute` events.
-   *
-   *   * in command handlers:
-   *
-   *     If the method {@link CommandHandler#canExecute} is implemented in a handler
-   *     it will be called to figure out whether the execution is allowed.
-   *
-   * @param  {string} command the command to execute
-   * @param  {Object} context the environment to execute the command in
-   *
-   * @return {boolean} true if the command can be executed
-   */
-  CommandStack.prototype.canExecute = function(command, context) {
+        dragging.cancel();
+        return;
+      }
 
-    const action = { command: command, context: context };
+      this.setActive(name);
 
-    const handler = this._getHandler(command);
+    }, this);
 
-    let result = this._fire(command, 'canExecute', action);
+    // Todo[ricardo]: add test cases
+    forEach$1(events, function(event) {
+      eventsToRegister.push(event + '.ended');
+      eventsToRegister.push(event + '.canceled');
+    });
 
-    // handler#canExecute will only be called if no listener
-    // decided on a result already
-    if (result === undefined) {
-      if (!handler) {
-        return false;
+    eventBus.on(eventsToRegister, LOW_PRIORITY$6, function(event) {
+
+      // We defer the de-activation of the tool to the .activate phase,
+      // so we're able to check if we want to toggle off the current
+      // active tool or switch to a new one
+      if (!this._active) {
+        return;
       }
 
-      if (handler.canExecute) {
-        result = handler.canExecute(context);
+      if (isPaletteClick(event)) {
+        return;
       }
-    }
 
-    return result;
+      this.setActive(null);
+    }, this);
+
   };
 
 
+  // helpers ///////////////
+
   /**
-   * Clear the command stack, erasing all undo / redo history
+   * Check if a given event is a palette click event.
+   *
+   * @param {EventBus.Event} event
+   *
+   * @return {boolean}
    */
-  CommandStack.prototype.clear = function(emit) {
-    this._stack.length = 0;
-    this._stackIdx = -1;
+  function isPaletteClick(event) {
+    var target = event.originalEvent && event.originalEvent.target;
 
-    if (emit !== false) {
-      this._fire('changed', { trigger: 'clear' });
-    }
-  };
+    return target && closest(target, '.group[data-group="tools"]');
+  }
 
+  var ToolManagerModule = {
+    __depends__: [
+      DraggingModule
+    ],
+    __init__: [ 'toolManager' ],
+    toolManager: [ 'type', ToolManager ]
+  };
 
   /**
-   * Undo last command(s)
+   * Return direction given axis and delta.
+   *
+   * @param {string} axis
+   * @param {number} delta
+   *
+   * @return {string}
    */
-  CommandStack.prototype.undo = function() {
-    let action = this._getUndoAction(),
-        next;
-
-    if (action) {
-      this._currentExecution.trigger = 'undo';
-
-      this._pushAction(action);
+  function getDirection(axis, delta) {
 
-      while (action) {
-        this._internalUndo(action);
-        next = this._getUndoAction();
+    if (axis === 'x') {
+      if (delta > 0) {
+        return 'e';
+      }
 
-        if (!next || next.id !== action.id) {
-          break;
-        }
+      if (delta < 0) {
+        return 'w';
+      }
+    }
 
-        action = next;
+    if (axis === 'y') {
+      if (delta > 0) {
+        return 's';
       }
 
-      this._popAction();
+      if (delta < 0) {
+        return 'n';
+      }
     }
-  };
 
+    return null;
+  }
 
   /**
-   * Redo last command(s)
+   * Returns connections whose waypoints are to be updated. Waypoints are to be updated if start
+   * or end is to be moved or resized.
+   *
+   * @param {Array<djs.model.Shape} movingShapes
+   * @param {Array<djs.model.Shape} resizingShapes
+   *
+   * @returns {Array<djs.model.Connection>}
    */
-  CommandStack.prototype.redo = function() {
-    let action = this._getRedoAction(),
-        next;
+  function getWaypointsUpdatingConnections(movingShapes, resizingShapes) {
+    var waypointsUpdatingConnections = [];
 
-    if (action) {
-      this._currentExecution.trigger = 'redo';
+    forEach$1(movingShapes.concat(resizingShapes), function(shape) {
+      var incoming = shape.incoming,
+          outgoing = shape.outgoing;
 
-      this._pushAction(action);
+      forEach$1(incoming.concat(outgoing), function(connection) {
+        var source = connection.source,
+            target = connection.target;
 
-      while (action) {
-        this._internalExecute(action, true);
-        next = this._getRedoAction();
+        if (includes$4(movingShapes, source) ||
+          includes$4(movingShapes, target) ||
+          includes$4(resizingShapes, source) ||
+          includes$4(resizingShapes, target)) {
 
-        if (!next || next.id !== action.id) {
-          break;
+          if (!includes$4(waypointsUpdatingConnections, connection)) {
+            waypointsUpdatingConnections.push(connection);
+          }
         }
+      });
+    });
 
-        action = next;
-      }
-
-      this._popAction();
-    }
-  };
+    return waypointsUpdatingConnections;
+  }
 
+  function includes$4(array, item) {
+    return array.indexOf(item) !== -1;
+  }
 
   /**
-   * Register a handler instance with the command stack
+   * Resize bounds.
    *
-   * @param {string} command
-   * @param {CommandHandler} handler
-   */
-  CommandStack.prototype.register = function(command, handler) {
-    this._setHandler(command, handler);
-  };
-
-
-  /**
-   * Register a handler type with the command stack
-   * by instantiating it and injecting its dependencies.
+   * @param {Object} bounds
+   * @param {number} bounds.x
+   * @param {number} bounds.y
+   * @param {number} bounds.width
+   * @param {number} bounds.height
+   * @param {string} direction
+   * @param {Object} delta
+   * @param {number} delta.x
+   * @param {number} delta.y
    *
-   * @param {string} command
-   * @param {Function} a constructor for a {@link CommandHandler}
+   * @return {Object}
    */
-  CommandStack.prototype.registerHandler = function(command, handlerCls) {
+  function resizeBounds(bounds, direction, delta) {
+    var x = bounds.x,
+        y = bounds.y,
+        width = bounds.width,
+        height = bounds.height,
+        dx = delta.x,
+        dy = delta.y;
 
-    if (!command || !handlerCls) {
-      throw new Error('command and handlerCls must be defined');
+    switch (direction) {
+    case 'n':
+      return {
+        x: x,
+        y: y + dy,
+        width: width,
+        height: height - dy
+      };
+    case 's':
+      return {
+        x: x,
+        y: y,
+        width: width,
+        height: height + dy
+      };
+    case 'w':
+      return {
+        x: x + dx,
+        y: y,
+        width: width - dx,
+        height: height
+      };
+    case 'e':
+      return {
+        x: x,
+        y: y,
+        width: width + dx,
+        height: height
+      };
+    default:
+      throw new Error('unknown direction: ' + direction);
     }
+  }
 
-    const handler = this._injector.instantiate(handlerCls);
-    this.register(command, handler);
-  };
-
-  CommandStack.prototype.canUndo = function() {
-    return !!this._getUndoAction();
-  };
+  var abs$1 = Math.abs,
+      round$4 = Math.round;
 
-  CommandStack.prototype.canRedo = function() {
-    return !!this._getRedoAction();
+  var AXIS_TO_DIMENSION = {
+    x: 'width',
+    y: 'height'
   };
 
-  // stack access  //////////////////////
+  var CURSOR_CROSSHAIR = 'crosshair';
 
-  CommandStack.prototype._getRedoAction = function() {
-    return this._stack[this._stackIdx + 1];
+  var DIRECTION_TO_TRBL = {
+    n: 'top',
+    w: 'left',
+    s: 'bottom',
+    e: 'right'
   };
 
+  var HIGH_PRIORITY$5 = 1500;
 
-  CommandStack.prototype._getUndoAction = function() {
-    return this._stack[this._stackIdx];
+  var DIRECTION_TO_OPPOSITE = {
+    n: 's',
+    w: 'e',
+    s: 'n',
+    e: 'w'
   };
 
+  var PADDING = 20;
 
-  // internal functionality //////////////////////
 
-  CommandStack.prototype._internalUndo = function(action) {
-    const command = action.command,
-          context = action.context;
+  /**
+   * Add or remove space by moving and resizing elements.
+   *
+   * @param {Canvas} canvas
+   * @param {Dragging} dragging
+   * @param {EventBus} eventBus
+   * @param {Modeling} modeling
+   * @param {Rules} rules
+   * @param {ToolManager} toolManager
+   * @param {Mouse} mouse
+   */
+  function SpaceTool(
+      canvas, dragging, eventBus,
+      modeling, rules, toolManager,
+      mouse) {
 
-    const handler = this._getHandler(command);
+    this._canvas = canvas;
+    this._dragging = dragging;
+    this._eventBus = eventBus;
+    this._modeling = modeling;
+    this._rules = rules;
+    this._toolManager = toolManager;
+    this._mouse = mouse;
 
-    // guard against illegal nested command stack invocations
-    this._atomicDo(() => {
-      this._fire(command, 'revert', action);
+    var self = this;
 
-      if (handler.revert) {
-        this._markDirty(handler.revert(context));
-      }
+    toolManager.registerTool('space', {
+      tool: 'spaceTool.selection',
+      dragging: 'spaceTool'
+    });
 
-      this._revertedAction(action);
+    eventBus.on('spaceTool.selection.end', function(event) {
+      eventBus.once('spaceTool.selection.ended', function() {
+        self.activateMakeSpace(event.originalEvent);
+      });
+    });
 
-      this._fire(command, 'reverted', action);
+    eventBus.on('spaceTool.move', HIGH_PRIORITY$5 , function(event) {
+      var context = event.context,
+          initialized = context.initialized;
+
+      if (!initialized) {
+        initialized = context.initialized = self.init(event, context);
+      }
+
+      if (initialized) {
+        ensureConstraints(event);
+      }
     });
-  };
 
+    eventBus.on('spaceTool.end', function(event) {
+      var context = event.context,
+          axis = context.axis,
+          direction = context.direction,
+          movingShapes = context.movingShapes,
+          resizingShapes = context.resizingShapes,
+          start = context.start;
+
+      if (!context.initialized) {
+        return;
+      }
 
-  CommandStack.prototype._fire = function(command, qualifier, event) {
-    if (arguments.length < 3) {
-      event = qualifier;
-      qualifier = null;
-    }
+      ensureConstraints(event);
 
-    const names = qualifier ? [ command + '.' + qualifier, qualifier ] : [ command ];
-    let result;
+      var delta = {
+        x: 0,
+        y: 0
+      };
 
-    event = this._eventBus.createEvent(event);
+      delta[ axis ] = round$4(event[ 'd' + axis ]);
 
-    for (const name of names) {
-      result = this._eventBus.fire('commandStack.' + name, event);
+      self.makeSpace(movingShapes, resizingShapes, delta, direction, start);
 
-      if (event.cancelBubble) {
-        break;
-      }
-    }
+      eventBus.once('spaceTool.ended', function(event) {
 
-    return result;
+        // activate space tool selection after make space
+        self.activateSelection(event.originalEvent, true, true);
+      });
+    });
+  }
+
+  SpaceTool.$inject = [
+    'canvas',
+    'dragging',
+    'eventBus',
+    'modeling',
+    'rules',
+    'toolManager',
+    'mouse'
+  ];
+
+  /**
+   * Activate space tool selection.
+   *
+   * @param {Object} event
+   * @param {boolean} autoActivate
+   */
+  SpaceTool.prototype.activateSelection = function(event, autoActivate, reactivate) {
+    this._dragging.init(event, 'spaceTool.selection', {
+      autoActivate: autoActivate,
+      cursor: CURSOR_CROSSHAIR,
+      data: {
+        context: {
+          reactivate: reactivate
+        }
+      },
+      trapClick: false
+    });
   };
 
-  CommandStack.prototype._createId = function() {
-    return this._uid++;
+  /**
+   * Activate space tool make space.
+   *
+   * @param  {MouseEvent} event
+   */
+  SpaceTool.prototype.activateMakeSpace = function(event) {
+    this._dragging.init(event, 'spaceTool', {
+      autoActivate: true,
+      cursor: CURSOR_CROSSHAIR,
+      data: {
+        context: {}
+      }
+    });
   };
 
-  CommandStack.prototype._atomicDo = function(fn) {
+  /**
+   * Make space.
+   *
+   * @param  {Array<djs.model.Shape>} movingShapes
+   * @param  {Array<djs.model.Shape>} resizingShapes
+   * @param  {Object} delta
+   * @param  {number} delta.x
+   * @param  {number} delta.y
+   * @param  {string} direction
+   * @param  {number} start
+   */
+  SpaceTool.prototype.makeSpace = function(movingShapes, resizingShapes, delta, direction, start) {
+    return this._modeling.createSpace(movingShapes, resizingShapes, delta, direction, start);
+  };
 
-    const execution = this._currentExecution;
+  /**
+   * Initialize make space and return true if that was successful.
+   *
+   * @param {Object} event
+   * @param {Object} context
+   *
+   * @return {boolean}
+   */
+  SpaceTool.prototype.init = function(event, context) {
+    var axis = abs$1(event.dx) > abs$1(event.dy) ? 'x' : 'y',
+        delta = event[ 'd' + axis ],
+        start = event[ axis ] - delta;
 
-    execution.atomic = true;
+    if (abs$1(delta) < 5) {
+      return false;
+    }
 
-    try {
-      fn();
-    } finally {
-      execution.atomic = false;
+    // invert delta to remove space when moving left
+    if (delta < 0) {
+      delta *= -1;
     }
-  };
 
-  CommandStack.prototype._internalExecute = function(action, redo) {
-    const command = action.command,
-          context = action.context;
+    // invert delta to add/remove space when removing/adding space if modifier key is pressed
+    if (hasPrimaryModifier(event)) {
+      delta *= -1;
+    }
 
-    const handler = this._getHandler(command);
+    var direction = getDirection(axis, delta);
 
-    if (!handler) {
-      throw new Error('no command handler registered for <' + command + '>');
-    }
+    var root = this._canvas.getRootElement();
 
-    this._pushAction(action);
+    var children = selfAndAllChildren(root, true);
 
-    if (!redo) {
-      this._fire(command, 'preExecute', action);
+    var elements = this.calculateAdjustments(children, axis, delta, start);
 
-      if (handler.preExecute) {
-        handler.preExecute(context);
+    var minDimensions = this._eventBus.fire('spaceTool.getMinDimensions', {
+      axis: axis,
+      direction: direction,
+      shapes: elements.resizingShapes,
+      start: start
+    });
+
+    var spaceToolConstraints = getSpaceToolConstraints(elements, axis, direction, start, minDimensions);
+
+    assign$1(
+      context,
+      elements,
+      {
+        axis: axis,
+        direction: direction,
+        spaceToolConstraints: spaceToolConstraints,
+        start: start
       }
+    );
 
-      this._fire(command, 'preExecuted', action);
-    }
+    set('resize-' + (axis === 'x' ? 'ew' : 'ns'));
 
-    // guard against illegal nested command stack invocations
-    this._atomicDo(() => {
+    return true;
+  };
 
-      this._fire(command, 'execute', action);
+  /**
+   * Get elements to be moved and resized.
+   *
+   * @param  {Array<djs.model.Shape>} elements
+   * @param  {string} axis
+   * @param  {number} delta
+   * @param  {number} start
+   *
+   * @return {Object}
+   */
+  SpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, start) {
+    var rules = this._rules;
 
-      if (handler.execute) {
+    var movingShapes = [],
+        resizingShapes = [];
 
-        // actual execute + mark return results as dirty
-        this._markDirty(handler.execute(context));
+    var attachers = [],
+        connections = [];
+
+    function moveShape(shape) {
+      if (!movingShapes.includes(shape)) {
+        movingShapes.push(shape);
       }
 
-      // log to stack
-      this._executedAction(action, redo);
+      var label = shape.label;
 
-      this._fire(command, 'executed', action);
-    });
+      // move external label if its label target is moving
+      if (label && !movingShapes.includes(label)) {
+        movingShapes.push(label);
+      }
+    }
 
-    if (!redo) {
-      this._fire(command, 'postExecute', action);
+    function resizeShape(shape) {
+      if (!resizingShapes.includes(shape)) {
+        resizingShapes.push(shape);
+      }
+    }
 
-      if (handler.postExecute) {
-        handler.postExecute(context);
+    forEach$1(elements, function(element) {
+      if (!element.parent || isLabel$2(element)) {
+        return;
       }
 
-      this._fire(command, 'postExecuted', action);
-    }
+      // handle connections separately
+      if (isConnection$7(element)) {
+        connections.push(element);
 
-    this._popAction(action);
-  };
+        return;
+      }
 
+      var shapeStart = element[ axis ],
+          shapeEnd = shapeStart + element[ AXIS_TO_DIMENSION[ axis ] ];
 
-  CommandStack.prototype._pushAction = function(action) {
+      // handle attachers separately
+      if (isAttacher$1(element)
+        && ((delta > 0 && getMid(element)[ axis ] > start)
+          || (delta < 0 && getMid(element)[ axis ] < start))) {
+        attachers.push(element);
 
-    const execution = this._currentExecution,
-          actions = execution.actions;
+        return;
+      }
 
-    const baseAction = actions[0];
+      // move shape if its start is after space tool
+      if ((delta > 0 && shapeStart > start)
+        || (delta < 0 && shapeEnd < start)) {
+        moveShape(element);
 
-    if (execution.atomic) {
-      throw new Error('illegal invocation in <execute> or <revert> phase (action: ' + action.command + ')');
-    }
+        return;
+      }
 
-    if (!action.id) {
-      action.id = (baseAction && baseAction.id) || this._createId();
-    }
+      // resize shape if it's resizable and its start is before and its end is after space tool
+      if (shapeStart < start
+        && shapeEnd > start
+        && rules.allowed('shape.resize', { shape: element })
+      ) {
+        resizeShape(element);
 
-    actions.push(action);
-  };
+        return;
+      }
+    });
 
+    // move attacher if its host is moving
+    forEach$1(movingShapes, function(shape) {
+      var attachers = shape.attachers;
 
-  CommandStack.prototype._popAction = function() {
-    const execution = this._currentExecution,
-          trigger = execution.trigger,
-          actions = execution.actions,
-          dirty = execution.dirty;
+      if (attachers) {
+        forEach$1(attachers, function(attacher) {
+          moveShape(attacher);
+        });
+      }
+    });
 
-    actions.pop();
+    var allShapes = movingShapes.concat(resizingShapes);
 
-    if (!actions.length) {
-      this._eventBus.fire('elements.changed', { elements: uniqueBy('id', dirty.reverse()) });
+    // move attacher if its mid is after space tool and its host is moving or resizing
+    forEach$1(attachers, function(attacher) {
+      var host = attacher.host;
 
-      dirty.length = 0;
+      if (includes$3(allShapes, host)) {
+        moveShape(attacher);
+      }
+    });
 
-      this._fire('changed', { trigger: trigger });
+    allShapes = movingShapes.concat(resizingShapes);
 
-      execution.trigger = null;
-    }
-  };
+    // move external label if its label target's (connection) source and target are moving
+    forEach$1(connections, function(connection) {
+      var source = connection.source,
+          target = connection.target,
+          label = connection.label;
 
+      if (includes$3(allShapes, source)
+        && includes$3(allShapes, target)
+        && label) {
+        moveShape(label);
+      }
+    });
 
-  CommandStack.prototype._markDirty = function(elements) {
-    const execution = this._currentExecution;
+    return {
+      movingShapes: movingShapes,
+      resizingShapes: resizingShapes
+    };
+  };
 
-    if (!elements) {
-      return;
+  SpaceTool.prototype.toggle = function() {
+
+    if (this.isActive()) {
+      return this._dragging.cancel();
     }
 
-    elements = isArray$3(elements) ? elements : [ elements ];
+    var mouseEvent = this._mouse.getLastMoveEvent();
 
-    execution.dirty = execution.dirty.concat(elements);
+    this.activateSelection(mouseEvent, !!mouseEvent);
   };
 
+  SpaceTool.prototype.isActive = function() {
+    var context = this._dragging.context();
 
-  CommandStack.prototype._executedAction = function(action, redo) {
-    const stackIdx = ++this._stackIdx;
-
-    if (!redo) {
-      this._stack.splice(stackIdx, this._stack.length, action);
+    if (context) {
+      return /^spaceTool/.test(context.prefix);
     }
+
+    return false;
   };
 
+  // helpers //////////
 
-  CommandStack.prototype._revertedAction = function(action) {
-    this._stackIdx--;
-  };
+  function addPadding(trbl) {
+    return {
+      top: trbl.top - PADDING,
+      right: trbl.right + PADDING,
+      bottom: trbl.bottom + PADDING,
+      left: trbl.left - PADDING
+    };
+  }
 
+  function ensureConstraints(event) {
+    var context = event.context,
+        spaceToolConstraints = context.spaceToolConstraints;
 
-  CommandStack.prototype._getHandler = function(command) {
-    return this._handlerMap[command];
-  };
+    if (!spaceToolConstraints) {
+      return;
+    }
 
-  CommandStack.prototype._setHandler = function(command, handler) {
-    if (!command || !handler) {
-      throw new Error('command and handler required');
+    var x, y;
+
+    if (isNumber(spaceToolConstraints.left)) {
+      x = Math.max(event.x, spaceToolConstraints.left);
+
+      event.dx = event.dx + x - event.x;
+      event.x = x;
     }
 
-    if (this._handlerMap[command]) {
-      throw new Error('overriding handler for command <' + command + '>');
+    if (isNumber(spaceToolConstraints.right)) {
+      x = Math.min(event.x, spaceToolConstraints.right);
+
+      event.dx = event.dx + x - event.x;
+      event.x = x;
     }
 
-    this._handlerMap[command] = handler;
-  };
+    if (isNumber(spaceToolConstraints.top)) {
+      y = Math.max(event.y, spaceToolConstraints.top);
 
-  var CommandModule = {
-    commandStack: [ 'type', CommandStack ]
-  };
+      event.dy = event.dy + y - event.y;
+      event.y = y;
+    }
 
-  // document wide unique tooltip ids
-  var ids = new IdGenerator('tt');
+    if (isNumber(spaceToolConstraints.bottom)) {
+      y = Math.min(event.y, spaceToolConstraints.bottom);
 
+      event.dy = event.dy + y - event.y;
+      event.y = y;
+    }
+  }
 
-  function createRoot(parentNode) {
-    var root = domify$1(
-      '<div class="djs-tooltip-container" />'
-    );
+  function getSpaceToolConstraints(elements, axis, direction, start, minDimensions) {
+    var movingShapes = elements.movingShapes,
+        resizingShapes = elements.resizingShapes;
 
-    assign(root, {
-      position: 'absolute',
-      width: '0',
-      height: '0'
-    });
+    if (!resizingShapes.length) {
+      return;
+    }
 
-    parentNode.insertBefore(root, parentNode.firstChild);
+    var spaceToolConstraints = {},
+        min,
+        max;
 
-    return root;
-  }
+    forEach$1(resizingShapes, function(resizingShape) {
+      var attachers = resizingShape.attachers,
+          children = resizingShape.children;
 
+      var resizingShapeBBox = asTRBL(resizingShape);
 
-  function setPosition(el, x, y) {
-    assign(el, { left: x + 'px', top: y + 'px' });
-  }
+      // find children that are not moving or resizing
+      var nonMovingResizingChildren = filter(children, function(child) {
+        return !isConnection$7(child) &&
+          !isLabel$2(child) &&
+          !includes$3(movingShapes, child) &&
+          !includes$3(resizingShapes, child);
+      });
 
-  function setVisible(el, visible) {
-    el.style.display = visible === false ? 'none' : '';
-  }
+      // find children that are moving
+      var movingChildren = filter(children, function(child) {
+        return !isConnection$7(child) && !isLabel$2(child) && includes$3(movingShapes, child);
+      });
 
+      var minOrMax,
+          nonMovingResizingChildrenBBox,
+          movingChildrenBBox,
+          movingAttachers = [],
+          nonMovingAttachers = [],
+          movingAttachersBBox,
+          movingAttachersConstraint,
+          nonMovingAttachersBBox,
+          nonMovingAttachersConstraint;
 
-  var tooltipClass = 'djs-tooltip',
-      tooltipSelector = '.' + tooltipClass;
+      if (nonMovingResizingChildren.length) {
+        nonMovingResizingChildrenBBox = addPadding(asTRBL(getBBox(nonMovingResizingChildren)));
 
-  /**
-   * A service that allows users to render tool tips on the diagram.
-   *
-   * The tooltip service will take care of updating the tooltip positioning
-   * during navigation + zooming.
-   *
-   * @example
-   *
-   * ```javascript
-   *
-   * // add a pink badge on the top left of the shape
-   * tooltips.add({
-   *   position: {
-   *     x: 50,
-   *     y: 100
-   *   },
-   *   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>'
-   * });
-   *
-   * // or with optional life span
-   * tooltips.add({
-   *   position: {
-   *     top: -5,
-   *     left: -5
-   *   },
-   *   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>',
-   *   ttl: 2000
-   * });
-   *
-   * // remove a tool tip
-   * var id = tooltips.add(...);
-   * tooltips.remove(id);
-   * ```
-   *
-   * @param {EventBus} eventBus
-   * @param {Canvas} canvas
-   */
-  function Tooltips(eventBus, canvas) {
+        minOrMax = start -
+          resizingShapeBBox[ DIRECTION_TO_TRBL[ direction ] ] +
+          nonMovingResizingChildrenBBox[ DIRECTION_TO_TRBL[ direction ] ];
 
-    this._eventBus = eventBus;
-    this._canvas = canvas;
+        if (direction === 'n') {
+          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 'w') {
+          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 's') {
+          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        } else if (direction === 'e') {
+          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        }
+      }
 
-    this._ids = ids;
+      if (movingChildren.length) {
+        movingChildrenBBox = addPadding(asTRBL(getBBox(movingChildren)));
 
-    this._tooltipDefaults = {
-      show: {
-        minZoom: 0.7,
-        maxZoom: 5.0
+        minOrMax = start -
+          movingChildrenBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ] +
+          resizingShapeBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ];
+
+        if (direction === 'n') {
+          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 'w') {
+          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 's') {
+          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        } else if (direction === 'e') {
+          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        }
       }
-    };
 
-    /**
-     * Mapping tooltipId -> tooltip
-     */
-    this._tooltips = {};
+      if (attachers && attachers.length) {
+        attachers.forEach(function(attacher) {
+          if (includes$3(movingShapes, attacher)) {
+            movingAttachers.push(attacher);
+          } else {
+            nonMovingAttachers.push(attacher);
+          }
+        });
 
-    // root html element for all tooltips
-    this._tooltipRoot = createRoot(canvas.getContainer());
+        if (movingAttachers.length) {
+          movingAttachersBBox = asTRBL(getBBox(movingAttachers.map(getMid)));
 
+          movingAttachersConstraint = resizingShapeBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ]
+                - (movingAttachersBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ] - start);
+        }
 
-    var self = this;
+        if (nonMovingAttachers.length) {
+          nonMovingAttachersBBox = asTRBL(getBBox(nonMovingAttachers.map(getMid)));
 
-    delegate.bind(this._tooltipRoot, tooltipSelector, 'mousedown', function(event) {
-      event.stopPropagation();
-    });
+          nonMovingAttachersConstraint = nonMovingAttachersBBox[ DIRECTION_TO_TRBL[ direction ] ]
+                - (resizingShapeBBox[ DIRECTION_TO_TRBL[ direction ] ] - start);
+        }
 
-    delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseover', function(event) {
-      self.trigger('mouseover', event);
-    });
+        if (direction === 'n') {
+          minOrMax = Math.min(movingAttachersConstraint || Infinity, nonMovingAttachersConstraint || Infinity);
 
-    delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseout', function(event) {
-      self.trigger('mouseout', event);
-    });
+          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 'w') {
+          minOrMax = Math.min(movingAttachersConstraint || Infinity, nonMovingAttachersConstraint || Infinity);
 
-    this._init();
-  }
+          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 's') {
+          minOrMax = Math.max(movingAttachersConstraint || -Infinity, nonMovingAttachersConstraint || -Infinity);
 
+          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        } else if (direction === 'e') {
+          minOrMax = Math.max(movingAttachersConstraint || -Infinity, nonMovingAttachersConstraint || -Infinity);
 
-  Tooltips.$inject = [ 'eventBus', 'canvas' ];
+          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        }
+      }
 
+      var resizingShapeMinDimensions = minDimensions && minDimensions[ resizingShape.id ];
 
-  /**
-   * Adds a HTML tooltip to the diagram
-   *
-   * @param {Object}               tooltip   the tooltip configuration
-   *
-   * @param {string|DOMElement}    tooltip.html                 html element to use as an tooltip
-   * @param {Object}               [tooltip.show]               show configuration
-   * @param {number}               [tooltip.show.minZoom]       minimal zoom level to show the tooltip
-   * @param {number}               [tooltip.show.maxZoom]       maximum zoom level to show the tooltip
-   * @param {Object}               tooltip.position             where to attach the tooltip
-   * @param {number}               [tooltip.position.left]      relative to element bbox left attachment
-   * @param {number}               [tooltip.position.top]       relative to element bbox top attachment
-   * @param {number}               [tooltip.position.bottom]    relative to element bbox bottom attachment
-   * @param {number}               [tooltip.position.right]     relative to element bbox right attachment
-   * @param {number}               [tooltip.timeout=-1]
-   *
-   * @return {string}              id that may be used to reference the tooltip for update or removal
-   */
-  Tooltips.prototype.add = function(tooltip) {
-
-    if (!tooltip.position) {
-      throw new Error('must specifiy tooltip position');
-    }
+      if (resizingShapeMinDimensions) {
 
-    if (!tooltip.html) {
-      throw new Error('must specifiy tooltip html');
-    }
+        if (direction === 'n') {
+          minOrMax = start +
+            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
+            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
 
-    var id = this._ids.next();
+          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 'w') {
+          minOrMax = start +
+            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
+            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
 
-    tooltip = assign$1({}, this._tooltipDefaults, tooltip, {
-      id: id
-    });
+          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
+        } else if (direction === 's') {
+          minOrMax = start -
+            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
+            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
 
-    this._addTooltip(tooltip);
+          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        } else if (direction === 'e') {
+          minOrMax = start -
+            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
+            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
 
-    if (tooltip.timeout) {
-      this.setTimeout(tooltip);
-    }
+          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
+        }
+      }
+    });
 
-    return id;
-  };
+    return spaceToolConstraints;
+  }
 
-  Tooltips.prototype.trigger = function(action, event) {
+  function includes$3(array, item) {
+    return array.indexOf(item) !== -1;
+  }
 
-    var node = event.delegateTarget || event.target;
+  function isAttacher$1(element) {
+    return !!element.host;
+  }
 
-    var tooltip = this.get(attr$1(node, 'data-tooltip-id'));
+  function isConnection$7(element) {
+    return !!element.waypoints;
+  }
 
-    if (!tooltip) {
-      return;
-    }
+  function isLabel$2(element) {
+    return !!element.labelTarget;
+  }
 
-    if (action === 'mouseover' && tooltip.timeout) {
-      this.clearTimeout(tooltip);
-    }
+  var MARKER_DRAGGING$1 = 'djs-dragging',
+      MARKER_RESIZING = 'djs-resizing';
 
-    if (action === 'mouseout' && tooltip.timeout) {
+  var LOW_PRIORITY$5 = 250;
 
-      // cut timeout after mouse out
-      tooltip.timeout = 1000;
+  var max = Math.max;
 
-      this.setTimeout(tooltip);
-    }
-  };
 
   /**
-   * Get a tooltip with the given id
+   * Provides previews for selecting/moving/resizing shapes when creating/removing space.
    *
-   * @param {string} id
+   * @param {EventBus} eventBus
+   * @param {ElementRegistry} elementRegistry
+   * @param {Canvas} canvas
+   * @param {Styles} styles
    */
-  Tooltips.prototype.get = function(id) {
-
-    if (typeof id !== 'string') {
-      id = id.id;
-    }
+  function SpaceToolPreview(
+      eventBus, elementRegistry, canvas,
+      styles, previewSupport) {
 
-    return this._tooltips[id];
-  };
+    function addPreviewGfx(collection, dragGroup) {
+      forEach$1(collection, function(element) {
+        previewSupport.addDragger(element, dragGroup);
 
-  Tooltips.prototype.clearTimeout = function(tooltip) {
+        canvas.addMarker(element, MARKER_DRAGGING$1);
+      });
+    }
 
-    tooltip = this.get(tooltip);
+    // add crosshair
+    eventBus.on('spaceTool.selection.start', function(event) {
+      var space = canvas.getLayer('space'),
+          context = event.context;
 
-    if (!tooltip) {
-      return;
-    }
+      var orientation = {
+        x: 'M 0,-10000 L 0,10000',
+        y: 'M -10000,0 L 10000,0'
+      };
 
-    var removeTimer = tooltip.removeTimer;
+      var crosshairGroup = create$1('g');
+      attr(crosshairGroup, styles.cls('djs-crosshair-group', [ 'no-events' ]));
 
-    if (removeTimer) {
-      clearTimeout(removeTimer);
-      tooltip.removeTimer = null;
-    }
-  };
+      append(space, crosshairGroup);
 
-  Tooltips.prototype.setTimeout = function(tooltip) {
+      // horizontal path
+      var pathX = create$1('path');
+      attr(pathX, 'd', orientation.x);
+      classes(pathX).add('djs-crosshair');
 
-    tooltip = this.get(tooltip);
+      append(crosshairGroup, pathX);
 
-    if (!tooltip) {
-      return;
-    }
+      // vertical path
+      var pathY = create$1('path');
+      attr(pathY, 'd', orientation.y);
+      classes(pathY).add('djs-crosshair');
 
-    this.clearTimeout(tooltip);
+      append(crosshairGroup, pathY);
 
-    var self = this;
+      context.crosshairGroup = crosshairGroup;
+    });
 
-    tooltip.removeTimer = setTimeout(function() {
-      self.remove(tooltip);
-    }, tooltip.timeout);
-  };
+    // update crosshair
+    eventBus.on('spaceTool.selection.move', function(event) {
+      var crosshairGroup = event.context.crosshairGroup;
 
-  /**
-   * Remove an tooltip with the given id
-   *
-   * @param {string} id
-   */
-  Tooltips.prototype.remove = function(id) {
+      translate$2(crosshairGroup, event.x, event.y);
+    });
 
-    var tooltip = this.get(id);
+    // remove crosshair
+    eventBus.on('spaceTool.selection.cleanup', function(event) {
+      var context = event.context,
+          crosshairGroup = context.crosshairGroup;
 
-    if (tooltip) {
-      remove$2(tooltip.html);
-      remove$2(tooltip.htmlContainer);
+      if (crosshairGroup) {
+        remove$1(crosshairGroup);
+      }
+    });
 
-      delete tooltip.htmlContainer;
+    // add and update move/resize previews
+    eventBus.on('spaceTool.move', LOW_PRIORITY$5, function(event) {
 
-      delete this._tooltips[tooltip.id];
-    }
-  };
+      var context = event.context,
+          line = context.line,
+          axis = context.axis,
+          movingShapes = context.movingShapes,
+          resizingShapes = context.resizingShapes;
 
+      if (!context.initialized) {
+        return;
+      }
 
-  Tooltips.prototype.show = function() {
-    setVisible(this._tooltipRoot);
-  };
+      if (!context.dragGroup) {
+        var spaceLayer = canvas.getLayer('space');
 
+        line = create$1('path');
+        attr(line, 'd', 'M0,0 L0,0');
+        classes(line).add('djs-crosshair');
 
-  Tooltips.prototype.hide = function() {
-    setVisible(this._tooltipRoot, false);
-  };
+        append(spaceLayer, line);
 
+        context.line = line;
 
-  Tooltips.prototype._updateRoot = function(viewbox) {
-    var a = viewbox.scale || 1;
-    var d = viewbox.scale || 1;
+        var dragGroup = create$1('g');
+        attr(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));
 
-    var matrix = 'matrix(' + a + ',0,0,' + d + ',' + (-1 * viewbox.x * a) + ',' + (-1 * viewbox.y * d) + ')';
+        append(canvas.getActiveLayer(), dragGroup);
 
-    this._tooltipRoot.style.transform = matrix;
-    this._tooltipRoot.style['-ms-transform'] = matrix;
-  };
+        // shapes
+        addPreviewGfx(movingShapes, dragGroup);
 
+        // connections
+        var movingConnections = context.movingConnections = elementRegistry.filter(function(element) {
+          var sourceIsMoving = false;
 
-  Tooltips.prototype._addTooltip = function(tooltip) {
+          forEach$1(movingShapes, function(shape) {
+            forEach$1(shape.outgoing, function(connection) {
+              if (element === connection) {
+                sourceIsMoving = true;
+              }
+            });
+          });
 
-    var id = tooltip.id,
-        html = tooltip.html,
-        htmlContainer,
-        tooltipRoot = this._tooltipRoot;
+          var targetIsMoving = false;
 
-    // unwrap jquery (for those who need it)
-    if (html.get && html.constructor.prototype.jquery) {
-      html = html.get(0);
-    }
+          forEach$1(movingShapes, function(shape) {
+            forEach$1(shape.incoming, function(connection) {
+              if (element === connection) {
+                targetIsMoving = true;
+              }
+            });
+          });
 
-    // create proper html elements from
-    // tooltip HTML strings
-    if (isString(html)) {
-      html = domify$1(html);
-    }
+          var sourceIsResizing = false;
 
-    htmlContainer = domify$1('<div data-tooltip-id="' + id + '" class="' + tooltipClass + '">');
-    assign(htmlContainer, { position: 'absolute' });
+          forEach$1(resizingShapes, function(shape) {
+            forEach$1(shape.outgoing, function(connection) {
+              if (element === connection) {
+                sourceIsResizing = true;
+              }
+            });
+          });
 
-    htmlContainer.appendChild(html);
+          var targetIsResizing = false;
 
-    if (tooltip.type) {
-      classes$1(htmlContainer).add('djs-tooltip-' + tooltip.type);
-    }
+          forEach$1(resizingShapes, function(shape) {
+            forEach$1(shape.incoming, function(connection) {
+              if (element === connection) {
+                targetIsResizing = true;
+              }
+            });
+          });
 
-    if (tooltip.className) {
-      classes$1(htmlContainer).add(tooltip.className);
-    }
+          return isConnection$6(element)
+            && (sourceIsMoving || sourceIsResizing)
+            && (targetIsMoving || targetIsResizing);
+        });
 
-    tooltip.htmlContainer = htmlContainer;
 
-    tooltipRoot.appendChild(htmlContainer);
+        addPreviewGfx(movingConnections, dragGroup);
 
-    this._tooltips[id] = tooltip;
+        context.dragGroup = dragGroup;
+      }
 
-    this._updateTooltip(tooltip);
-  };
+      if (!context.frameGroup) {
+        var frameGroup = create$1('g');
+        attr(frameGroup, styles.cls('djs-frame-group', [ 'no-events' ]));
 
+        append(canvas.getActiveLayer(), frameGroup);
 
-  Tooltips.prototype._updateTooltip = function(tooltip) {
+        var frames = [];
 
-    var position = tooltip.position,
-        htmlContainer = tooltip.htmlContainer;
+        forEach$1(resizingShapes, function(shape) {
+          var frame = previewSupport.addFrame(shape, frameGroup);
 
-    // update overlay html based on tooltip x, y
+          var initialBounds = frame.getBBox();
 
-    setPosition(htmlContainer, position.x, position.y);
-  };
+          frames.push({
+            element: frame,
+            initialBounds: initialBounds
+          });
 
+          canvas.addMarker(shape, MARKER_RESIZING);
+        });
 
-  Tooltips.prototype._updateTooltipVisibilty = function(viewbox) {
+        context.frameGroup = frameGroup;
+        context.frames = frames;
+      }
 
-    forEach$1(this._tooltips, function(tooltip) {
-      var show = tooltip.show,
-          htmlContainer = tooltip.htmlContainer,
-          visible = true;
+      var orientation = {
+        x: 'M' + event.x + ', -10000 L' + event.x + ', 10000',
+        y: 'M -10000, ' + event.y + ' L 10000, ' + event.y
+      };
 
-      if (show) {
-        if (show.minZoom > viewbox.scale ||
-            show.maxZoom < viewbox.scale) {
-          visible = false;
-        }
+      attr(line, { d: orientation[ axis ] });
 
-        setVisible(htmlContainer, visible);
-      }
-    });
-  };
+      var opposite = { x: 'y', y: 'x' };
+      var delta = { x: event.dx, y: event.dy };
+      delta[ opposite[ context.axis ] ] = 0;
 
-  Tooltips.prototype._init = function() {
+      // update move previews
+      translate$2(context.dragGroup, delta.x, delta.y);
 
-    var self = this;
+      // update resize previews
+      forEach$1(context.frames, function(frame) {
+        var element = frame.element,
+            initialBounds = frame.initialBounds,
+            width,
+            height;
 
-    // scroll/zoom integration
+        if (context.direction === 'e') {
+          attr(element, {
+            width: max(initialBounds.width + delta.x, 5)
+          });
+        } else {
+          width = max(initialBounds.width - delta.x, 5);
 
-    function updateViewbox(viewbox) {
-      self._updateRoot(viewbox);
-      self._updateTooltipVisibilty(viewbox);
+          attr(element, {
+            width: width,
+            x: initialBounds.x + initialBounds.width - width
+          });
+        }
 
-      self.show();
-    }
+        if (context.direction === 's') {
+          attr(element, {
+            height: max(initialBounds.height + delta.y, 5)
+          });
+        } else {
+          height = max(initialBounds.height - delta.y, 5);
 
-    this._eventBus.on('canvas.viewbox.changing', function(event) {
-      self.hide();
-    });
+          attr(element, {
+            height: height,
+            y: initialBounds.y + initialBounds.height - height
+          });
+        }
+      });
 
-    this._eventBus.on('canvas.viewbox.changed', function(event) {
-      updateViewbox(event.viewbox);
     });
-  };
 
-  var TooltipsModule = {
-    __init__: [ 'tooltips' ],
-    tooltips: [ 'type', Tooltips ]
-  };
+    // remove move/resize previews
+    eventBus.on('spaceTool.cleanup', function(event) {
 
-  /**
-   * Remove from the beginning of a collection until it is empty.
-   *
-   * This is a null-safe operation that ensures elements
-   * are being removed from the given collection until the
-   * collection is empty.
-   *
-   * The implementation deals with the fact that a remove operation
-   * may touch, i.e. remove multiple elements in the collection
-   * at a time.
-   *
-   * @param {Array<Object>} [collection]
-   * @param {Function} removeFn
-   *
-   * @return {Array<Object>} the cleared collection
-   */
-  function saveClear(collection, removeFn) {
+      var context = event.context,
+          movingShapes = context.movingShapes,
+          movingConnections = context.movingConnections,
+          resizingShapes = context.resizingShapes,
+          line = context.line,
+          dragGroup = context.dragGroup,
+          frameGroup = context.frameGroup;
 
-    if (typeof removeFn !== 'function') {
-      throw new Error('removeFn iterator must be a function');
-    }
+      // moving shapes
+      forEach$1(movingShapes, function(shape) {
+        canvas.removeMarker(shape, MARKER_DRAGGING$1);
+      });
 
-    if (!collection) {
-      return;
-    }
+      // moving connections
+      forEach$1(movingConnections, function(connection) {
+        canvas.removeMarker(connection, MARKER_DRAGGING$1);
+      });
 
-    var e;
+      if (dragGroup) {
+        remove$1(line);
+        remove$1(dragGroup);
+      }
 
-    while ((e = collection[0])) {
-      removeFn(e);
-    }
+      forEach$1(resizingShapes, function(shape) {
+        canvas.removeMarker(shape, MARKER_RESIZING);
+      });
 
-    return collection;
+      if (frameGroup) {
+        remove$1(frameGroup);
+      }
+    });
   }
 
-  var LOW_PRIORITY$6 = 250,
-      HIGH_PRIORITY$5 = 1400;
+  SpaceToolPreview.$inject = [
+    'eventBus',
+    'elementRegistry',
+    'canvas',
+    'styles',
+    'previewSupport'
+  ];
+
 
+  // helpers //////////////////////
 
   /**
-   * A handler that makes sure labels are properly moved with
-   * their label targets.
-   *
-   * @param {didi.Injector} injector
-   * @param {EventBus} eventBus
-   * @param {Modeling} modeling
+   * Checks if an element is a connection.
    */
-  function LabelSupport(injector, eventBus, modeling) {
-
-    CommandInterceptor.call(this, eventBus);
-
-    var movePreview = injector.get('movePreview', false);
-
-    // remove labels from the collection that are being
-    // moved with other elements anyway
-    eventBus.on('shape.move.start', HIGH_PRIORITY$5, function(e) {
-
-      var context = e.context,
-          shapes = context.shapes,
-          validatedShapes = context.validatedShapes;
-
-      context.shapes = removeLabels(shapes);
-      context.validatedShapes = removeLabels(validatedShapes);
-    });
-
-    // add labels to visual's group
-    movePreview && eventBus.on('shape.move.start', LOW_PRIORITY$6, function(e) {
+  function isConnection$6(element) {
+    return element.waypoints;
+  }
 
-      var context = e.context,
-          shapes = context.shapes;
+  var SpaceToolModule$1 = {
+    __init__: [ 'spaceToolPreview' ],
+    __depends__: [
+      DraggingModule,
+      RulesModule$1,
+      ToolManagerModule,
+      PreviewSupportModule,
+      MouseModule
+    ],
+    spaceTool: [ 'type', SpaceTool ],
+    spaceToolPreview: [ 'type', SpaceToolPreview ]
+  };
 
-      var labels = [];
+  function BpmnSpaceTool(injector) {
+    injector.invoke(SpaceTool, this);
+  }
 
-      forEach$1(shapes, function(element) {
+  BpmnSpaceTool.$inject = [
+    'injector'
+  ];
 
-        forEach$1(element.labels, function(label) {
+  e(BpmnSpaceTool, SpaceTool);
 
-          if (!label.hidden && context.shapes.indexOf(label) === -1) {
-            labels.push(label);
-          }
+  BpmnSpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, start) {
+    var adjustments = SpaceTool.prototype.calculateAdjustments.call(this, elements, axis, delta, start);
 
-          if (element.labelTarget) {
-            labels.push(element);
-          }
-        });
-      });
+    // do not resize text annotations
+    adjustments.resizingShapes = adjustments.resizingShapes.filter(function(shape) {
+      return !is$1(shape, 'bpmn:TextAnnotation');
+    });
 
-      forEach$1(labels, function(label) {
-        movePreview.makeDraggable(context, label, true);
-      });
+    return adjustments;
+  };
 
-    });
+  var SpaceToolModule = {
+    __depends__: [ SpaceToolModule$1 ],
+    spaceTool: [ 'type', BpmnSpaceTool ]
+  };
 
-    // add all labels to move closure
-    this.preExecuted('elements.move', HIGH_PRIORITY$5, function(e) {
-      var context = e.context,
-          closure = context.closure,
-          enclosedElements = closure.enclosedElements;
+  /**
+   * A service that offers un- and redoable execution of commands.
+   *
+   * The command stack is responsible for executing modeling actions
+   * in a un- and redoable manner. To do this it delegates the actual
+   * command execution to {@link CommandHandler}s.
+   *
+   * Command handlers provide {@link CommandHandler#execute(ctx)} and
+   * {@link CommandHandler#revert(ctx)} methods to un- and redo a command
+   * identified by a command context.
+   *
+   *
+   * ## Life-Cycle events
+   *
+   * In the process the command stack fires a number of life-cycle events
+   * that other components to participate in the command execution.
+   *
+   *    * preExecute
+   *    * preExecuted
+   *    * execute
+   *    * executed
+   *    * postExecute
+   *    * postExecuted
+   *    * revert
+   *    * reverted
+   *
+   * A special event is used for validating, whether a command can be
+   * performed prior to its execution.
+   *
+   *    * canExecute
+   *
+   * Each of the events is fired as `commandStack.{eventName}` and
+   * `commandStack.{commandName}.{eventName}`, respectively. This gives
+   * components fine grained control on where to hook into.
+   *
+   * The event object fired transports `command`, the name of the
+   * command and `context`, the command context.
+   *
+   *
+   * ## Creating Command Handlers
+   *
+   * Command handlers should provide the {@link CommandHandler#execute(ctx)}
+   * and {@link CommandHandler#revert(ctx)} methods to implement
+   * redoing and undoing of a command.
+   *
+   * A command handler _must_ ensure undo is performed properly in order
+   * not to break the undo chain. It must also return the shapes that
+   * got changed during the `execute` and `revert` operations.
+   *
+   * Command handlers may execute other modeling operations (and thus
+   * commands) in their `preExecute` and `postExecute` phases. The command
+   * stack will properly group all commands together into a logical unit
+   * that may be re- and undone atomically.
+   *
+   * Command handlers must not execute other commands from within their
+   * core implementation (`execute`, `revert`).
+   *
+   *
+   * ## Change Tracking
+   *
+   * During the execution of the CommandStack it will keep track of all
+   * elements that have been touched during the command's execution.
+   *
+   * At the end of the CommandStack execution it will notify interested
+   * components via an 'elements.changed' event with all the dirty
+   * elements.
+   *
+   * The event can be picked up by components that are interested in the fact
+   * that elements have been changed. One use case for this is updating
+   * their graphical representation after moving / resizing or deletion.
+   *
+   * @see CommandHandler
+   *
+   * @param {EventBus} eventBus
+   * @param {Injector} injector
+   */
+  function CommandStack(eventBus, injector) {
 
-      var enclosedLabels = [];
+    /**
+     * A map of all registered command handlers.
+     *
+     * @type {Object}
+     */
+    this._handlerMap = {};
 
-      // find labels that are not part of
-      // move closure yet and add them
-      forEach$1(enclosedElements, function(element) {
-        forEach$1(element.labels, function(label) {
+    /**
+     * A stack containing all re/undoable actions on the diagram
+     *
+     * @type {Array<Object>}
+     */
+    this._stack = [];
 
-          if (!enclosedElements[label.id]) {
-            enclosedLabels.push(label);
-          }
-        });
-      });
+    /**
+     * The current index on the stack
+     *
+     * @type {number}
+     */
+    this._stackIdx = -1;
 
-      closure.addAll(enclosedLabels);
-    });
+    /**
+     * Current active commandStack execution
+     *
+     * @type {Object}
+     * @property {Object[]} actions
+     * @property {Object[]} dirty
+     * @property { 'undo' | 'redo' | 'clear' | 'execute' | null } trigger the cause of the current excecution
+     */
+    this._currentExecution = {
+      actions: [],
+      dirty: [],
+      trigger: null
+    };
 
 
-    this.preExecute([
-      'connection.delete',
-      'shape.delete'
-    ], function(e) {
+    this._injector = injector;
+    this._eventBus = eventBus;
 
-      var context = e.context,
-          element = context.connection || context.shape;
+    this._uid = 1;
 
-      saveClear(element.labels, function(label) {
-        modeling.removeShape(label, { nested: true });
-      });
-    });
+    eventBus.on([
+      'diagram.destroy',
+      'diagram.clear'
+    ], function() {
+      this.clear(false);
+    }, this);
+  }
 
+  CommandStack.$inject = [ 'eventBus', 'injector' ];
 
-    this.execute('shape.delete', function(e) {
 
-      var context = e.context,
-          shape = context.shape,
-          labelTarget = shape.labelTarget;
+  /**
+   * Execute a command
+   *
+   * @param {string} command the command to execute
+   * @param {Object} context the environment to execute the command in
+   */
+  CommandStack.prototype.execute = function(command, context) {
+    if (!command) {
+      throw new Error('command required');
+    }
 
-      // unset labelTarget
-      if (labelTarget) {
-        context.labelTargetIndex = indexOf(labelTarget.labels, shape);
-        context.labelTarget = labelTarget;
+    this._currentExecution.trigger = 'execute';
 
-        shape.labelTarget = null;
-      }
-    });
+    const action = { command: command, context: context };
 
-    this.revert('shape.delete', function(e) {
+    this._pushAction(action);
+    this._internalExecute(action);
+    this._popAction(action);
+  };
 
-      var context = e.context,
-          shape = context.shape,
-          labelTarget = context.labelTarget,
-          labelTargetIndex = context.labelTargetIndex;
 
-      // restore labelTarget
-      if (labelTarget) {
-        add(labelTarget.labels, shape, labelTargetIndex);
+  /**
+   * Ask whether a given command can be executed.
+   *
+   * Implementors may hook into the mechanism on two ways:
+   *
+   *   * in event listeners:
+   *
+   *     Users may prevent the execution via an event listener.
+   *     It must prevent the default action for `commandStack.(<command>.)canExecute` events.
+   *
+   *   * in command handlers:
+   *
+   *     If the method {@link CommandHandler#canExecute} is implemented in a handler
+   *     it will be called to figure out whether the execution is allowed.
+   *
+   * @param  {string} command the command to execute
+   * @param  {Object} context the environment to execute the command in
+   *
+   * @return {boolean} true if the command can be executed
+   */
+  CommandStack.prototype.canExecute = function(command, context) {
 
-        shape.labelTarget = labelTarget;
+    const action = { command: command, context: context };
+
+    const handler = this._getHandler(command);
+
+    let result = this._fire(command, 'canExecute', action);
+
+    // handler#canExecute will only be called if no listener
+    // decided on a result already
+    if (result === undefined) {
+      if (!handler) {
+        return false;
       }
-    });
 
-  }
+      if (handler.canExecute) {
+        result = handler.canExecute(context);
+      }
+    }
 
-  e(LabelSupport, CommandInterceptor);
+    return result;
+  };
 
-  LabelSupport.$inject = [
-    'injector',
-    'eventBus',
-    'modeling'
-  ];
+
+  /**
+   * Clear the command stack, erasing all undo / redo history
+   */
+  CommandStack.prototype.clear = function(emit) {
+    this._stack.length = 0;
+    this._stackIdx = -1;
+
+    if (emit !== false) {
+      this._fire('changed', { trigger: 'clear' });
+    }
+  };
 
 
   /**
-   * Return a filtered list of elements that do not
-   * contain attached elements with hosts being part
-   * of the selection.
-   *
-   * @param  {Array<djs.model.Base>} elements
-   *
-   * @return {Array<djs.model.Base>} filtered
+   * Undo last command(s)
    */
-  function removeLabels(elements) {
+  CommandStack.prototype.undo = function() {
+    let action = this._getUndoAction(),
+        next;
 
-    return filter(elements, function(element) {
+    if (action) {
+      this._currentExecution.trigger = 'undo';
 
-      // filter out labels that are move together
-      // with their label targets
-      return elements.indexOf(element.labelTarget) === -1;
-    });
-  }
+      this._pushAction(action);
 
-  var LabelSupportModule = {
-    __init__: [ 'labelSupport' ],
-    labelSupport: [ 'type', LabelSupport ]
-  };
+      while (action) {
+        this._internalUndo(action);
+        next = this._getUndoAction();
 
-  var LOW_PRIORITY$5 = 251,
-      HIGH_PRIORITY$4 = 1401;
+        if (!next || next.id !== action.id) {
+          break;
+        }
 
-  var MARKER_ATTACH$1 = 'attach-ok';
+        action = next;
+      }
+
+      this._popAction();
+    }
+  };
 
 
   /**
-   * Adds the notion of attached elements to the modeler.
-   *
-   * Optionally depends on `diagram-js/lib/features/move` to render
-   * the attached elements during move preview.
-   *
-   * Optionally depends on `diagram-js/lib/features/label-support`
-   * to render attached labels during move preview.
-   *
-   * @param {didi.Injector} injector
-   * @param {EventBus} eventBus
-   * @param {Canvas} canvas
-   * @param {Rules} rules
-   * @param {Modeling} modeling
+   * Redo last command(s)
    */
-  function AttachSupport(injector, eventBus, canvas, rules, modeling) {
-
-    CommandInterceptor.call(this, eventBus);
+  CommandStack.prototype.redo = function() {
+    let action = this._getRedoAction(),
+        next;
 
-    var movePreview = injector.get('movePreview', false);
+    if (action) {
+      this._currentExecution.trigger = 'redo';
 
+      this._pushAction(action);
 
-    // remove all the attached elements from the shapes to be validated
-    // add all the attached shapes to the overall list of moved shapes
-    eventBus.on('shape.move.start', HIGH_PRIORITY$4, function(e) {
+      while (action) {
+        this._internalExecute(action, true);
+        next = this._getRedoAction();
 
-      var context = e.context,
-          shapes = context.shapes,
-          validatedShapes = context.validatedShapes;
+        if (!next || next.id !== action.id) {
+          break;
+        }
 
-      context.shapes = addAttached(shapes);
+        action = next;
+      }
 
-      context.validatedShapes = removeAttached(validatedShapes);
-    });
+      this._popAction();
+    }
+  };
 
-    // add attachers to the visual's group
-    movePreview && eventBus.on('shape.move.start', LOW_PRIORITY$5, function(e) {
 
-      var context = e.context,
-          shapes = context.shapes,
-          attachers = getAttachers(shapes);
+  /**
+   * Register a handler instance with the command stack
+   *
+   * @param {string} command
+   * @param {CommandHandler} handler
+   */
+  CommandStack.prototype.register = function(command, handler) {
+    this._setHandler(command, handler);
+  };
 
-      forEach$1(attachers, function(attacher) {
-        movePreview.makeDraggable(context, attacher, true);
 
-        forEach$1(attacher.labels, function(label) {
-          movePreview.makeDraggable(context, label, true);
-        });
-      });
-    });
+  /**
+   * Register a handler type with the command stack
+   * by instantiating it and injecting its dependencies.
+   *
+   * @param {string} command
+   * @param {Function} a constructor for a {@link CommandHandler}
+   */
+  CommandStack.prototype.registerHandler = function(command, handlerCls) {
 
-    // add attach-ok marker to current host
-    movePreview && eventBus.on('shape.move.start', function(event) {
-      var context = event.context,
-          shapes = context.shapes;
+    if (!command || !handlerCls) {
+      throw new Error('command and handlerCls must be defined');
+    }
 
-      if (shapes.length !== 1) {
-        return;
-      }
+    const handler = this._injector.instantiate(handlerCls);
+    this.register(command, handler);
+  };
 
-      var shape = shapes[0];
+  CommandStack.prototype.canUndo = function() {
+    return !!this._getUndoAction();
+  };
 
-      var host = shape.host;
+  CommandStack.prototype.canRedo = function() {
+    return !!this._getRedoAction();
+  };
 
-      if (host) {
-        canvas.addMarker(host, MARKER_ATTACH$1);
+  // stack access  //////////////////////
 
-        eventBus.once([
-          'shape.move.out',
-          'shape.move.cleanup'
-        ], function() {
-          canvas.removeMarker(host, MARKER_ATTACH$1);
-        });
-      }
-    });
+  CommandStack.prototype._getRedoAction = function() {
+    return this._stack[this._stackIdx + 1];
+  };
 
-    // add all attachers to move closure
-    this.preExecuted('elements.move', HIGH_PRIORITY$4, function(e) {
-      var context = e.context,
-          closure = context.closure,
-          shapes = context.shapes,
-          attachers = getAttachers(shapes);
 
-      forEach$1(attachers, function(attacher) {
-        closure.add(attacher, closure.topLevel[attacher.host.id]);
-      });
-    });
+  CommandStack.prototype._getUndoAction = function() {
+    return this._stack[this._stackIdx];
+  };
 
-    // perform the attaching after shapes are done moving
-    this.postExecuted('elements.move', function(e) {
 
-      var context = e.context,
-          shapes = context.shapes,
-          newHost = context.newHost,
-          attachers;
+  // internal functionality //////////////////////
 
-      // only single elements can be attached
-      // multiply elements can be detached
-      if (newHost && shapes.length !== 1) {
-        return;
-      }
+  CommandStack.prototype._internalUndo = function(action) {
+    const command = action.command,
+          context = action.context;
 
-      if (newHost) {
-        attachers = shapes;
-      } else {
+    const handler = this._getHandler(command);
 
-        // find attachers moved without host
-        attachers = filter(shapes, function(shape) {
-          var host = shape.host;
+    // guard against illegal nested command stack invocations
+    this._atomicDo(() => {
+      this._fire(command, 'revert', action);
 
-          return isAttacher(shape) && !includes$4(shapes, host);
-        });
+      if (handler.revert) {
+        this._markDirty(handler.revert(context));
       }
 
-      forEach$1(attachers, function(attacher) {
-        modeling.updateAttachment(attacher, newHost);
-      });
-    });
+      this._revertedAction(action);
 
-    // ensure invalid attachment connections are removed
-    this.postExecuted('elements.move', function(e) {
+      this._fire(command, 'reverted', action);
+    });
+  };
 
-      var shapes = e.context.shapes;
 
-      forEach$1(shapes, function(shape) {
+  CommandStack.prototype._fire = function(command, qualifier, event) {
+    if (arguments.length < 3) {
+      event = qualifier;
+      qualifier = null;
+    }
 
-        forEach$1(shape.attachers, function(attacher) {
+    const names = qualifier ? [ command + '.' + qualifier, qualifier ] : [ command ];
+    let result;
 
-          // remove invalid outgoing connections
-          forEach$1(attacher.outgoing.slice(), function(connection) {
-            var allowed = rules.allowed('connection.reconnect', {
-              connection: connection,
-              source: connection.source,
-              target: connection.target
-            });
+    event = this._eventBus.createEvent(event);
 
-            if (!allowed) {
-              modeling.removeConnection(connection);
-            }
-          });
+    for (const name of names) {
+      result = this._eventBus.fire('commandStack.' + name, event);
 
-          // remove invalid incoming connections
-          forEach$1(attacher.incoming.slice(), function(connection) {
-            var allowed = rules.allowed('connection.reconnect', {
-              connection: connection,
-              source: connection.source,
-              target: connection.target
-            });
+      if (event.cancelBubble) {
+        break;
+      }
+    }
 
-            if (!allowed) {
-              modeling.removeConnection(connection);
-            }
-          });
-        });
-      });
-    });
+    return result;
+  };
 
-    this.postExecute('shape.create', function(e) {
-      var context = e.context,
-          shape = context.shape,
-          host = context.host;
+  CommandStack.prototype._createId = function() {
+    return this._uid++;
+  };
 
-      if (host) {
-        modeling.updateAttachment(shape, host);
-      }
-    });
+  CommandStack.prototype._atomicDo = function(fn) {
 
-    // update attachments if the host is replaced
-    this.postExecute('shape.replace', function(e) {
+    const execution = this._currentExecution;
 
-      var context = e.context,
-          oldShape = context.oldShape,
-          newShape = context.newShape;
+    execution.atomic = true;
 
-      // move the attachers to the new host
-      saveClear(oldShape.attachers, function(attacher) {
-        var allowed = rules.allowed('elements.move', {
-          target: newShape,
-          shapes: [ attacher ]
-        });
+    try {
+      fn();
+    } finally {
+      execution.atomic = false;
+    }
+  };
 
-        if (allowed === 'attach') {
-          modeling.updateAttachment(attacher, newShape);
-        } else {
-          modeling.removeShape(attacher);
-        }
-      });
+  CommandStack.prototype._internalExecute = function(action, redo) {
+    const command = action.command,
+          context = action.context;
 
-      // move attachers if new host has different size
-      if (newShape.attachers.length) {
+    const handler = this._getHandler(command);
 
-        forEach$1(newShape.attachers, function(attacher) {
-          var delta = getNewAttachShapeDelta(attacher, oldShape, newShape);
-          modeling.moveShape(attacher, delta, attacher.parent);
-        });
-      }
+    if (!handler) {
+      throw new Error('no command handler registered for <' + command + '>');
+    }
 
-    });
+    this._pushAction(action);
 
-    // move shape on host resize
-    this.postExecute('shape.resize', function(event) {
-      var context = event.context,
-          shape = context.shape,
-          oldBounds = context.oldBounds,
-          newBounds = context.newBounds,
-          attachers = shape.attachers,
-          hints = context.hints || {};
+    if (!redo) {
+      this._fire(command, 'preExecute', action);
 
-      if (hints.attachSupport === false) {
-        return;
+      if (handler.preExecute) {
+        handler.preExecute(context);
       }
 
-      forEach$1(attachers, function(attacher) {
-        var delta = getNewAttachShapeDelta(attacher, oldBounds, newBounds);
+      this._fire(command, 'preExecuted', action);
+    }
 
-        modeling.moveShape(attacher, delta, attacher.parent);
+    // guard against illegal nested command stack invocations
+    this._atomicDo(() => {
 
-        forEach$1(attacher.labels, function(label) {
-          modeling.moveShape(label, delta, label.parent);
-        });
-      });
-    });
+      this._fire(command, 'execute', action);
 
-    // remove attachments
-    this.preExecute('shape.delete', function(event) {
+      if (handler.execute) {
 
-      var shape = event.context.shape;
+        // actual execute + mark return results as dirty
+        this._markDirty(handler.execute(context));
+      }
 
-      saveClear(shape.attachers, function(attacher) {
-        modeling.removeShape(attacher);
-      });
+      // log to stack
+      this._executedAction(action, redo);
 
-      if (shape.host) {
-        modeling.updateAttachment(shape, null);
-      }
+      this._fire(command, 'executed', action);
     });
-  }
 
-  e(AttachSupport, CommandInterceptor);
+    if (!redo) {
+      this._fire(command, 'postExecute', action);
 
-  AttachSupport.$inject = [
-    'injector',
-    'eventBus',
-    'canvas',
-    'rules',
-    'modeling'
-  ];
+      if (handler.postExecute) {
+        handler.postExecute(context);
+      }
 
+      this._fire(command, 'postExecuted', action);
+    }
 
-  /**
-   * Return attachers of the given shapes
-   *
-   * @param {Array<djs.model.Base>} shapes
-   * @return {Array<djs.model.Base>}
-   */
-  function getAttachers(shapes) {
-    return flatten(map$1(shapes, function(s) {
-      return s.attachers || [];
-    }));
-  }
+    this._popAction(action);
+  };
 
-  /**
-   * Return a combined list of elements and
-   * attachers.
-   *
-   * @param {Array<djs.model.Base>} elements
-   * @return {Array<djs.model.Base>} filtered
-   */
-  function addAttached(elements) {
-    var attachers = getAttachers(elements);
 
-    return unionBy('id', elements, attachers);
-  }
+  CommandStack.prototype._pushAction = function(action) {
 
-  /**
-   * Return a filtered list of elements that do not
-   * contain attached elements with hosts being part
-   * of the selection.
-   *
-   * @param  {Array<djs.model.Base>} elements
-   *
-   * @return {Array<djs.model.Base>} filtered
-   */
-  function removeAttached(elements) {
+    const execution = this._currentExecution,
+          actions = execution.actions;
 
-    var ids = groupBy(elements, 'id');
+    const baseAction = actions[0];
 
-    return filter(elements, function(element) {
-      while (element) {
+    if (execution.atomic) {
+      throw new Error('illegal invocation in <execute> or <revert> phase (action: ' + action.command + ')');
+    }
 
-        // host in selection
-        if (element.host && ids[element.host.id]) {
-          return false;
-        }
+    if (!action.id) {
+      action.id = (baseAction && baseAction.id) || this._createId();
+    }
 
-        element = element.parent;
-      }
+    actions.push(action);
+  };
 
-      return true;
-    });
-  }
 
-  function isAttacher(shape) {
-    return !!shape.host;
-  }
+  CommandStack.prototype._popAction = function() {
+    const execution = this._currentExecution,
+          trigger = execution.trigger,
+          actions = execution.actions,
+          dirty = execution.dirty;
 
-  function includes$4(array, item) {
-    return array.indexOf(item) !== -1;
-  }
+    actions.pop();
 
-  var AttachSupportModule = {
-    __depends__: [
-      RulesModule$1
-    ],
-    __init__: [ 'attachSupport' ],
-    attachSupport: [ 'type', AttachSupport ]
-  };
+    if (!actions.length) {
+      this._eventBus.fire('elements.changed', { elements: uniqueBy('id', dirty.reverse()) });
 
-  var LOW_PRIORITY$4 = 250;
+      dirty.length = 0;
 
-  /**
-   * The tool manager acts as middle-man between the available tool's and the Palette,
-   * it takes care of making sure that the correct active state is set.
-   *
-   * @param  {Object}    eventBus
-   * @param  {Object}    dragging
-   */
-  function ToolManager(eventBus, dragging) {
-    this._eventBus = eventBus;
-    this._dragging = dragging;
+      this._fire('changed', { trigger: trigger });
 
-    this._tools = [];
-    this._active = null;
-  }
+      execution.trigger = null;
+    }
+  };
 
-  ToolManager.$inject = [ 'eventBus', 'dragging' ];
 
-  ToolManager.prototype.registerTool = function(name, events) {
-    var tools = this._tools;
+  CommandStack.prototype._markDirty = function(elements) {
+    const execution = this._currentExecution;
 
-    if (!events) {
-      throw new Error('A tool has to be registered with it\'s "events"');
+    if (!elements) {
+      return;
     }
 
-    tools.push(name);
+    elements = isArray$3(elements) ? elements : [ elements ];
 
-    this.bindEvents(name, events);
+    execution.dirty = execution.dirty.concat(elements);
   };
 
-  ToolManager.prototype.isActive = function(tool) {
-    return tool && this._active === tool;
-  };
 
-  ToolManager.prototype.length = function(tool) {
-    return this._tools.length;
+  CommandStack.prototype._executedAction = function(action, redo) {
+    const stackIdx = ++this._stackIdx;
+
+    if (!redo) {
+      this._stack.splice(stackIdx, this._stack.length, action);
+    }
   };
 
-  ToolManager.prototype.setActive = function(tool) {
-    var eventBus = this._eventBus;
 
-    if (this._active !== tool) {
-      this._active = tool;
+  CommandStack.prototype._revertedAction = function(action) {
+    this._stackIdx--;
+  };
 
-      eventBus.fire('tool-manager.update', { tool: tool });
-    }
+
+  CommandStack.prototype._getHandler = function(command) {
+    return this._handlerMap[command];
   };
 
-  ToolManager.prototype.bindEvents = function(name, events) {
-    var eventBus = this._eventBus,
-        dragging = this._dragging;
+  CommandStack.prototype._setHandler = function(command, handler) {
+    if (!command || !handler) {
+      throw new Error('command and handler required');
+    }
 
-    var eventsToRegister = [];
+    if (this._handlerMap[command]) {
+      throw new Error('overriding handler for command <' + command + '>');
+    }
 
-    eventBus.on(events.tool + '.init', function(event) {
-      var context = event.context;
+    this._handlerMap[command] = handler;
+  };
 
-      // Active tools that want to reactivate themselves must do this explicitly
-      if (!context.reactivate && this.isActive(name)) {
-        this.setActive(null);
+  var CommandModule = {
+    commandStack: [ 'type', CommandStack ]
+  };
 
-        dragging.cancel();
-        return;
-      }
+  // document wide unique tooltip ids
+  var ids = new IdGenerator('tt');
 
-      this.setActive(name);
 
-    }, this);
+  function createRoot(parentNode) {
+    var root = domify$1(
+      '<div class="djs-tooltip-container" />'
+    );
 
-    // Todo[ricardo]: add test cases
-    forEach$1(events, function(event) {
-      eventsToRegister.push(event + '.ended');
-      eventsToRegister.push(event + '.canceled');
+    assign(root, {
+      position: 'absolute',
+      width: '0',
+      height: '0'
     });
 
-    eventBus.on(eventsToRegister, LOW_PRIORITY$4, function(event) {
+    parentNode.insertBefore(root, parentNode.firstChild);
 
-      // We defer the de-activation of the tool to the .activate phase,
-      // so we're able to check if we want to toggle off the current
-      // active tool or switch to a new one
-      if (!this._active) {
-        return;
-      }
+    return root;
+  }
 
-      if (isPaletteClick(event)) {
-        return;
-      }
 
-      this.setActive(null);
-    }, this);
+  function setPosition(el, x, y) {
+    assign(el, { left: x + 'px', top: y + 'px' });
+  }
 
-  };
+  function setVisible(el, visible) {
+    el.style.display = visible === false ? 'none' : '';
+  }
 
 
-  // helpers ///////////////
+  var tooltipClass = 'djs-tooltip',
+      tooltipSelector = '.' + tooltipClass;
 
   /**
-   * Check if a given event is a palette click event.
+   * A service that allows users to render tool tips on the diagram.
    *
-   * @param {EventBus.Event} event
+   * The tooltip service will take care of updating the tooltip positioning
+   * during navigation + zooming.
    *
-   * @return {boolean}
+   * @example
+   *
+   * ```javascript
+   *
+   * // add a pink badge on the top left of the shape
+   * tooltips.add({
+   *   position: {
+   *     x: 50,
+   *     y: 100
+   *   },
+   *   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>'
+   * });
+   *
+   * // or with optional life span
+   * tooltips.add({
+   *   position: {
+   *     top: -5,
+   *     left: -5
+   *   },
+   *   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>',
+   *   ttl: 2000
+   * });
+   *
+   * // remove a tool tip
+   * var id = tooltips.add(...);
+   * tooltips.remove(id);
+   * ```
+   *
+   * @param {EventBus} eventBus
+   * @param {Canvas} canvas
    */
-  function isPaletteClick(event) {
-    var target = event.originalEvent && event.originalEvent.target;
+  function Tooltips(eventBus, canvas) {
 
-    return target && closest(target, '.group[data-group="tools"]');
+    this._eventBus = eventBus;
+    this._canvas = canvas;
+
+    this._ids = ids;
+
+    this._tooltipDefaults = {
+      show: {
+        minZoom: 0.7,
+        maxZoom: 5.0
+      }
+    };
+
+    /**
+     * Mapping tooltipId -> tooltip
+     */
+    this._tooltips = {};
+
+    // root html element for all tooltips
+    this._tooltipRoot = createRoot(canvas.getContainer());
+
+
+    var self = this;
+
+    delegate.bind(this._tooltipRoot, tooltipSelector, 'mousedown', function(event) {
+      event.stopPropagation();
+    });
+
+    delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseover', function(event) {
+      self.trigger('mouseover', event);
+    });
+
+    delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseout', function(event) {
+      self.trigger('mouseout', event);
+    });
+
+    this._init();
   }
 
-  var ToolManagerModule = {
-    __depends__: [
-      DraggingModule
-    ],
-    __init__: [ 'toolManager' ],
-    toolManager: [ 'type', ToolManager ]
-  };
+
+  Tooltips.$inject = [ 'eventBus', 'canvas' ];
+
 
   /**
-   * Return direction given axis and delta.
+   * Adds a HTML tooltip to the diagram
    *
-   * @param {string} axis
-   * @param {number} delta
+   * @param {Object}               tooltip   the tooltip configuration
    *
-   * @return {string}
+   * @param {string|DOMElement}    tooltip.html                 html element to use as an tooltip
+   * @param {Object}               [tooltip.show]               show configuration
+   * @param {number}               [tooltip.show.minZoom]       minimal zoom level to show the tooltip
+   * @param {number}               [tooltip.show.maxZoom]       maximum zoom level to show the tooltip
+   * @param {Object}               tooltip.position             where to attach the tooltip
+   * @param {number}               [tooltip.position.left]      relative to element bbox left attachment
+   * @param {number}               [tooltip.position.top]       relative to element bbox top attachment
+   * @param {number}               [tooltip.position.bottom]    relative to element bbox bottom attachment
+   * @param {number}               [tooltip.position.right]     relative to element bbox right attachment
+   * @param {number}               [tooltip.timeout=-1]
+   *
+   * @return {string}              id that may be used to reference the tooltip for update or removal
    */
-  function getDirection(axis, delta) {
+  Tooltips.prototype.add = function(tooltip) {
 
-    if (axis === 'x') {
-      if (delta > 0) {
-        return 'e';
-      }
+    if (!tooltip.position) {
+      throw new Error('must specifiy tooltip position');
+    }
 
-      if (delta < 0) {
-        return 'w';
-      }
+    if (!tooltip.html) {
+      throw new Error('must specifiy tooltip html');
     }
 
-    if (axis === 'y') {
-      if (delta > 0) {
-        return 's';
-      }
+    var id = this._ids.next();
 
-      if (delta < 0) {
-        return 'n';
-      }
+    tooltip = assign$1({}, this._tooltipDefaults, tooltip, {
+      id: id
+    });
+
+    this._addTooltip(tooltip);
+
+    if (tooltip.timeout) {
+      this.setTimeout(tooltip);
     }
 
-    return null;
-  }
+    return id;
+  };
 
-  /**
-   * Returns connections whose waypoints are to be updated. Waypoints are to be updated if start
-   * or end is to be moved or resized.
-   *
-   * @param {Array<djs.model.Shape} movingShapes
-   * @param {Array<djs.model.Shape} resizingShapes
-   *
-   * @returns {Array<djs.model.Connection>}
-   */
-  function getWaypointsUpdatingConnections(movingShapes, resizingShapes) {
-    var waypointsUpdatingConnections = [];
+  Tooltips.prototype.trigger = function(action, event) {
 
-    forEach$1(movingShapes.concat(resizingShapes), function(shape) {
-      var incoming = shape.incoming,
-          outgoing = shape.outgoing;
+    var node = event.delegateTarget || event.target;
 
-      forEach$1(incoming.concat(outgoing), function(connection) {
-        var source = connection.source,
-            target = connection.target;
+    var tooltip = this.get(attr$1(node, 'data-tooltip-id'));
 
-        if (includes$3(movingShapes, source) ||
-          includes$3(movingShapes, target) ||
-          includes$3(resizingShapes, source) ||
-          includes$3(resizingShapes, target)) {
+    if (!tooltip) {
+      return;
+    }
 
-          if (!includes$3(waypointsUpdatingConnections, connection)) {
-            waypointsUpdatingConnections.push(connection);
-          }
-        }
-      });
-    });
+    if (action === 'mouseover' && tooltip.timeout) {
+      this.clearTimeout(tooltip);
+    }
 
-    return waypointsUpdatingConnections;
-  }
+    if (action === 'mouseout' && tooltip.timeout) {
 
-  function includes$3(array, item) {
-    return array.indexOf(item) !== -1;
-  }
+      // cut timeout after mouse out
+      tooltip.timeout = 1000;
+
+      this.setTimeout(tooltip);
+    }
+  };
 
   /**
-   * Resize bounds.
-   *
-   * @param {Object} bounds
-   * @param {number} bounds.x
-   * @param {number} bounds.y
-   * @param {number} bounds.width
-   * @param {number} bounds.height
-   * @param {string} direction
-   * @param {Object} delta
-   * @param {number} delta.x
-   * @param {number} delta.y
+   * Get a tooltip with the given id
    *
-   * @return {Object}
+   * @param {string} id
    */
-  function resizeBounds(bounds, direction, delta) {
-    var x = bounds.x,
-        y = bounds.y,
-        width = bounds.width,
-        height = bounds.height,
-        dx = delta.x,
-        dy = delta.y;
+  Tooltips.prototype.get = function(id) {
 
-    switch (direction) {
-    case 'n':
-      return {
-        x: x,
-        y: y + dy,
-        width: width,
-        height: height - dy
-      };
-    case 's':
-      return {
-        x: x,
-        y: y,
-        width: width,
-        height: height + dy
-      };
-    case 'w':
-      return {
-        x: x + dx,
-        y: y,
-        width: width - dx,
-        height: height
-      };
-    case 'e':
-      return {
-        x: x,
-        y: y,
-        width: width + dx,
-        height: height
-      };
-    default:
-      throw new Error('unknown direction: ' + direction);
+    if (typeof id !== 'string') {
+      id = id.id;
+    }
+
+    return this._tooltips[id];
+  };
+
+  Tooltips.prototype.clearTimeout = function(tooltip) {
+
+    tooltip = this.get(tooltip);
+
+    if (!tooltip) {
+      return;
     }
-  }
 
-  var abs$1 = Math.abs,
-      round$4 = Math.round;
+    var removeTimer = tooltip.removeTimer;
 
-  var AXIS_TO_DIMENSION = {
-    x: 'width',
-    y: 'height'
+    if (removeTimer) {
+      clearTimeout(removeTimer);
+      tooltip.removeTimer = null;
+    }
   };
 
-  var CURSOR_CROSSHAIR = 'crosshair';
+  Tooltips.prototype.setTimeout = function(tooltip) {
 
-  var DIRECTION_TO_TRBL = {
-    n: 'top',
-    w: 'left',
-    s: 'bottom',
-    e: 'right'
-  };
+    tooltip = this.get(tooltip);
 
-  var HIGH_PRIORITY$3 = 1500;
+    if (!tooltip) {
+      return;
+    }
 
-  var DIRECTION_TO_OPPOSITE = {
-    n: 's',
-    w: 'e',
-    s: 'n',
-    e: 'w'
-  };
+    this.clearTimeout(tooltip);
 
-  var PADDING = 20;
+    var self = this;
 
+    tooltip.removeTimer = setTimeout(function() {
+      self.remove(tooltip);
+    }, tooltip.timeout);
+  };
 
   /**
-   * Add or remove space by moving and resizing elements.
+   * Remove an tooltip with the given id
    *
-   * @param {Canvas} canvas
-   * @param {Dragging} dragging
-   * @param {EventBus} eventBus
-   * @param {Modeling} modeling
-   * @param {Rules} rules
-   * @param {ToolManager} toolManager
-   * @param {Mouse} mouse
+   * @param {string} id
    */
-  function SpaceTool(
-      canvas, dragging, eventBus,
-      modeling, rules, toolManager,
-      mouse) {
-
-    this._canvas = canvas;
-    this._dragging = dragging;
-    this._eventBus = eventBus;
-    this._modeling = modeling;
-    this._rules = rules;
-    this._toolManager = toolManager;
-    this._mouse = mouse;
-
-    var self = this;
+  Tooltips.prototype.remove = function(id) {
 
-    toolManager.registerTool('space', {
-      tool: 'spaceTool.selection',
-      dragging: 'spaceTool'
-    });
+    var tooltip = this.get(id);
 
-    eventBus.on('spaceTool.selection.end', function(event) {
-      eventBus.once('spaceTool.selection.ended', function() {
-        self.activateMakeSpace(event.originalEvent);
-      });
-    });
+    if (tooltip) {
+      remove$2(tooltip.html);
+      remove$2(tooltip.htmlContainer);
 
-    eventBus.on('spaceTool.move', HIGH_PRIORITY$3 , function(event) {
-      var context = event.context,
-          initialized = context.initialized;
+      delete tooltip.htmlContainer;
 
-      if (!initialized) {
-        initialized = context.initialized = self.init(event, context);
-      }
+      delete this._tooltips[tooltip.id];
+    }
+  };
 
-      if (initialized) {
-        ensureConstraints(event);
-      }
-    });
 
-    eventBus.on('spaceTool.end', function(event) {
-      var context = event.context,
-          axis = context.axis,
-          direction = context.direction,
-          movingShapes = context.movingShapes,
-          resizingShapes = context.resizingShapes,
-          start = context.start;
+  Tooltips.prototype.show = function() {
+    setVisible(this._tooltipRoot);
+  };
 
-      if (!context.initialized) {
-        return;
-      }
 
-      ensureConstraints(event);
+  Tooltips.prototype.hide = function() {
+    setVisible(this._tooltipRoot, false);
+  };
 
-      var delta = {
-        x: 0,
-        y: 0
-      };
 
-      delta[ axis ] = round$4(event[ 'd' + axis ]);
+  Tooltips.prototype._updateRoot = function(viewbox) {
+    var a = viewbox.scale || 1;
+    var d = viewbox.scale || 1;
 
-      self.makeSpace(movingShapes, resizingShapes, delta, direction, start);
+    var matrix = 'matrix(' + a + ',0,0,' + d + ',' + (-1 * viewbox.x * a) + ',' + (-1 * viewbox.y * d) + ')';
 
-      eventBus.once('spaceTool.ended', function(event) {
+    this._tooltipRoot.style.transform = matrix;
+    this._tooltipRoot.style['-ms-transform'] = matrix;
+  };
 
-        // activate space tool selection after make space
-        self.activateSelection(event.originalEvent, true, true);
-      });
-    });
-  }
 
-  SpaceTool.$inject = [
-    'canvas',
-    'dragging',
-    'eventBus',
-    'modeling',
-    'rules',
-    'toolManager',
-    'mouse'
-  ];
+  Tooltips.prototype._addTooltip = function(tooltip) {
 
-  /**
-   * Activate space tool selection.
-   *
-   * @param {Object} event
-   * @param {boolean} autoActivate
-   */
-  SpaceTool.prototype.activateSelection = function(event, autoActivate, reactivate) {
-    this._dragging.init(event, 'spaceTool.selection', {
-      autoActivate: autoActivate,
-      cursor: CURSOR_CROSSHAIR,
-      data: {
-        context: {
-          reactivate: reactivate
-        }
-      },
-      trapClick: false
-    });
-  };
+    var id = tooltip.id,
+        html = tooltip.html,
+        htmlContainer,
+        tooltipRoot = this._tooltipRoot;
 
-  /**
-   * Activate space tool make space.
-   *
-   * @param  {MouseEvent} event
-   */
-  SpaceTool.prototype.activateMakeSpace = function(event) {
-    this._dragging.init(event, 'spaceTool', {
-      autoActivate: true,
-      cursor: CURSOR_CROSSHAIR,
-      data: {
-        context: {}
-      }
-    });
-  };
+    // unwrap jquery (for those who need it)
+    if (html.get && html.constructor.prototype.jquery) {
+      html = html.get(0);
+    }
 
-  /**
-   * Make space.
-   *
-   * @param  {Array<djs.model.Shape>} movingShapes
-   * @param  {Array<djs.model.Shape>} resizingShapes
-   * @param  {Object} delta
-   * @param  {number} delta.x
-   * @param  {number} delta.y
-   * @param  {string} direction
-   * @param  {number} start
-   */
-  SpaceTool.prototype.makeSpace = function(movingShapes, resizingShapes, delta, direction, start) {
-    return this._modeling.createSpace(movingShapes, resizingShapes, delta, direction, start);
-  };
+    // create proper html elements from
+    // tooltip HTML strings
+    if (isString(html)) {
+      html = domify$1(html);
+    }
 
-  /**
-   * Initialize make space and return true if that was successful.
-   *
-   * @param {Object} event
-   * @param {Object} context
-   *
-   * @return {boolean}
-   */
-  SpaceTool.prototype.init = function(event, context) {
-    var axis = abs$1(event.dx) > abs$1(event.dy) ? 'x' : 'y',
-        delta = event[ 'd' + axis ],
-        start = event[ axis ] - delta;
+    htmlContainer = domify$1('<div data-tooltip-id="' + id + '" class="' + tooltipClass + '">');
+    assign(htmlContainer, { position: 'absolute' });
 
-    if (abs$1(delta) < 5) {
-      return false;
-    }
+    htmlContainer.appendChild(html);
 
-    // invert delta to remove space when moving left
-    if (delta < 0) {
-      delta *= -1;
+    if (tooltip.type) {
+      classes$1(htmlContainer).add('djs-tooltip-' + tooltip.type);
     }
 
-    // invert delta to add/remove space when removing/adding space if modifier key is pressed
-    if (hasPrimaryModifier(event)) {
-      delta *= -1;
+    if (tooltip.className) {
+      classes$1(htmlContainer).add(tooltip.className);
     }
 
-    var direction = getDirection(axis, delta);
+    tooltip.htmlContainer = htmlContainer;
 
-    var root = this._canvas.getRootElement();
+    tooltipRoot.appendChild(htmlContainer);
 
-    var children = selfAndAllChildren(root, true);
+    this._tooltips[id] = tooltip;
 
-    var elements = this.calculateAdjustments(children, axis, delta, start);
+    this._updateTooltip(tooltip);
+  };
 
-    var minDimensions = this._eventBus.fire('spaceTool.getMinDimensions', {
-      axis: axis,
-      direction: direction,
-      shapes: elements.resizingShapes,
-      start: start
-    });
 
-    var spaceToolConstraints = getSpaceToolConstraints(elements, axis, direction, start, minDimensions);
+  Tooltips.prototype._updateTooltip = function(tooltip) {
 
-    assign$1(
-      context,
-      elements,
-      {
-        axis: axis,
-        direction: direction,
-        spaceToolConstraints: spaceToolConstraints,
-        start: start
-      }
-    );
+    var position = tooltip.position,
+        htmlContainer = tooltip.htmlContainer;
 
-    set('resize-' + (axis === 'x' ? 'ew' : 'ns'));
+    // update overlay html based on tooltip x, y
 
-    return true;
+    setPosition(htmlContainer, position.x, position.y);
   };
 
-  /**
-   * Get elements to be moved and resized.
-   *
-   * @param  {Array<djs.model.Shape>} elements
-   * @param  {string} axis
-   * @param  {number} delta
-   * @param  {number} start
-   *
-   * @return {Object}
-   */
-  SpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, start) {
-    var rules = this._rules;
 
-    var movingShapes = [],
-        resizingShapes = [];
+  Tooltips.prototype._updateTooltipVisibilty = function(viewbox) {
 
-    forEach$1(elements, function(element) {
-      if (!element.parent || isConnection$7(element)) {
-        return;
-      }
+    forEach$1(this._tooltips, function(tooltip) {
+      var show = tooltip.show,
+          htmlContainer = tooltip.htmlContainer,
+          visible = true;
 
-      var shapeStart = element[ axis ],
-          shapeEnd = shapeStart + element[ AXIS_TO_DIMENSION[ axis ] ];
+      if (show) {
+        if (show.minZoom > viewbox.scale ||
+            show.maxZoom < viewbox.scale) {
+          visible = false;
+        }
 
-      // shape to be moved
-      if ((delta > 0 && shapeStart > start) || (delta < 0 && shapeEnd < start)) {
-        return movingShapes.push(element);
+        setVisible(htmlContainer, visible);
       }
+    });
+  };
 
-      // shape to be resized
-      if (shapeStart < start &&
-        shapeEnd > start &&
-        rules.allowed('shape.resize', { shape: element })
-      ) {
+  Tooltips.prototype._init = function() {
 
-        return resizingShapes.push(element);
-      }
-    });
+    var self = this;
 
-    return {
-      movingShapes: movingShapes,
-      resizingShapes: resizingShapes
-    };
-  };
+    // scroll/zoom integration
 
-  SpaceTool.prototype.toggle = function() {
+    function updateViewbox(viewbox) {
+      self._updateRoot(viewbox);
+      self._updateTooltipVisibilty(viewbox);
 
-    if (this.isActive()) {
-      return this._dragging.cancel();
+      self.show();
     }
 
-    var mouseEvent = this._mouse.getLastMoveEvent();
+    this._eventBus.on('canvas.viewbox.changing', function(event) {
+      self.hide();
+    });
 
-    this.activateSelection(mouseEvent, !!mouseEvent);
+    this._eventBus.on('canvas.viewbox.changed', function(event) {
+      updateViewbox(event.viewbox);
+    });
   };
 
-  SpaceTool.prototype.isActive = function() {
-    var context = this._dragging.context();
-
-    return context && /^spaceTool/.test(context.prefix);
+  var TooltipsModule = {
+    __init__: [ 'tooltips' ],
+    tooltips: [ 'type', Tooltips ]
   };
 
-  // helpers //////////
-
-  function addPadding(trbl) {
-    return {
-      top: trbl.top - PADDING,
-      right: trbl.right + PADDING,
-      bottom: trbl.bottom + PADDING,
-      left: trbl.left - PADDING
-    };
-  }
+  /**
+   * Remove from the beginning of a collection until it is empty.
+   *
+   * This is a null-safe operation that ensures elements
+   * are being removed from the given collection until the
+   * collection is empty.
+   *
+   * The implementation deals with the fact that a remove operation
+   * may touch, i.e. remove multiple elements in the collection
+   * at a time.
+   *
+   * @param {Array<Object>} [collection]
+   * @param {Function} removeFn
+   *
+   * @return {Array<Object>} the cleared collection
+   */
+  function saveClear(collection, removeFn) {
 
-  function ensureConstraints(event) {
-    var context = event.context,
-        spaceToolConstraints = context.spaceToolConstraints;
+    if (typeof removeFn !== 'function') {
+      throw new Error('removeFn iterator must be a function');
+    }
 
-    if (!spaceToolConstraints) {
+    if (!collection) {
       return;
     }
 
-    var x, y;
-
-    if (isNumber(spaceToolConstraints.left)) {
-      x = Math.max(event.x, spaceToolConstraints.left);
+    var e;
 
-      event.dx = event.dx + x - event.x;
-      event.x = x;
+    while ((e = collection[0])) {
+      removeFn(e);
     }
 
-    if (isNumber(spaceToolConstraints.right)) {
-      x = Math.min(event.x, spaceToolConstraints.right);
+    return collection;
+  }
 
-      event.dx = event.dx + x - event.x;
-      event.x = x;
-    }
+  var LOW_PRIORITY$4 = 250,
+      HIGH_PRIORITY$4 = 1400;
 
-    if (isNumber(spaceToolConstraints.top)) {
-      y = Math.max(event.y, spaceToolConstraints.top);
 
-      event.dy = event.dy + y - event.y;
-      event.y = y;
-    }
+  /**
+   * A handler that makes sure labels are properly moved with
+   * their label targets.
+   *
+   * @param {didi.Injector} injector
+   * @param {EventBus} eventBus
+   * @param {Modeling} modeling
+   */
+  function LabelSupport(injector, eventBus, modeling) {
 
-    if (isNumber(spaceToolConstraints.bottom)) {
-      y = Math.min(event.y, spaceToolConstraints.bottom);
+    CommandInterceptor.call(this, eventBus);
 
-      event.dy = event.dy + y - event.y;
-      event.y = y;
-    }
-  }
+    var movePreview = injector.get('movePreview', false);
 
-  function getSpaceToolConstraints(elements, axis, direction, start, minDimensions) {
-    var movingShapes = elements.movingShapes,
-        resizingShapes = elements.resizingShapes;
+    // remove labels from the collection that are being
+    // moved with other elements anyway
+    eventBus.on('shape.move.start', HIGH_PRIORITY$4, function(e) {
 
-    if (!resizingShapes.length) {
-      return;
-    }
+      var context = e.context,
+          shapes = context.shapes,
+          validatedShapes = context.validatedShapes;
 
-    var spaceToolConstraints = {},
-        min,
-        max;
+      context.shapes = removeLabels(shapes);
+      context.validatedShapes = removeLabels(validatedShapes);
+    });
 
-    forEach$1(resizingShapes, function(resizingShape) {
-      var resizingShapeBBox = asTRBL(resizingShape);
+    // add labels to visual's group
+    movePreview && eventBus.on('shape.move.start', LOW_PRIORITY$4, function(e) {
 
-      // find children that are not moving or resizing
-      var nonMovingResizingChildren = filter(resizingShape.children, function(child) {
-        return !isConnection$7(child) &&
-          !isLabel$2(child) &&
-          !includes$2(movingShapes, child) &&
-          !includes$2(resizingShapes, child);
+      var context = e.context,
+          shapes = context.shapes;
+
+      var labels = [];
+
+      forEach$1(shapes, function(element) {
+
+        forEach$1(element.labels, function(label) {
+
+          if (!label.hidden && context.shapes.indexOf(label) === -1) {
+            labels.push(label);
+          }
+
+          if (element.labelTarget) {
+            labels.push(element);
+          }
+        });
       });
 
-      // find children that are moving
-      var movingChildren = filter(resizingShape.children, function(child) {
-        return !isConnection$7(child) && !isLabel$2(child) && includes$2(movingShapes, child);
+      forEach$1(labels, function(label) {
+        movePreview.makeDraggable(context, label, true);
       });
 
-      var minOrMax,
-          nonMovingResizingChildrenBBox,
-          movingChildrenBBox;
+    });
 
-      if (nonMovingResizingChildren.length) {
-        nonMovingResizingChildrenBBox = addPadding(asTRBL(getBBox(nonMovingResizingChildren)));
+    // add all labels to move closure
+    this.preExecuted('elements.move', HIGH_PRIORITY$4, function(e) {
+      var context = e.context,
+          closure = context.closure,
+          enclosedElements = closure.enclosedElements;
 
-        minOrMax = start -
-          resizingShapeBBox[ DIRECTION_TO_TRBL[ direction ] ] +
-          nonMovingResizingChildrenBBox[ DIRECTION_TO_TRBL[ direction ] ];
+      var enclosedLabels = [];
 
-        if (direction === 'n') {
-          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
-        } else if (direction === 'w') {
-          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
-        } else if (direction === 's') {
-          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
-        } else if (direction === 'e') {
-          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
-        }
-      }
+      // find labels that are not part of
+      // move closure yet and add them
+      forEach$1(enclosedElements, function(element) {
+        forEach$1(element.labels, function(label) {
 
-      if (movingChildren.length) {
-        movingChildrenBBox = addPadding(asTRBL(getBBox(movingChildren)));
+          if (!enclosedElements[label.id]) {
+            enclosedLabels.push(label);
+          }
+        });
+      });
 
-        minOrMax = start -
-          movingChildrenBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ] +
-          resizingShapeBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ];
+      closure.addAll(enclosedLabels);
+    });
 
-        if (direction === 'n') {
-          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
-        } else if (direction === 'w') {
-          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
-        } else if (direction === 's') {
-          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
-        } else if (direction === 'e') {
-          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
-        }
-      }
 
-      var resizingShapeMinDimensions = minDimensions && minDimensions[ resizingShape.id ];
+    this.preExecute([
+      'connection.delete',
+      'shape.delete'
+    ], function(e) {
+
+      var context = e.context,
+          element = context.connection || context.shape;
+
+      saveClear(element.labels, function(label) {
+        modeling.removeShape(label, { nested: true });
+      });
+    });
+
+
+    this.execute('shape.delete', function(e) {
+
+      var context = e.context,
+          shape = context.shape,
+          labelTarget = shape.labelTarget;
+
+      // unset labelTarget
+      if (labelTarget) {
+        context.labelTargetIndex = indexOf(labelTarget.labels, shape);
+        context.labelTarget = labelTarget;
 
-      if (resizingShapeMinDimensions) {
-        if (direction === 'n') {
-          minOrMax = start +
-            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
-            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
+        shape.labelTarget = null;
+      }
+    });
 
-          spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
-        } else if (direction === 'w') {
-          minOrMax = start +
-            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
-            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
+    this.revert('shape.delete', function(e) {
 
-          spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
-        } else if (direction === 's') {
-          minOrMax = start -
-            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
-            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
+      var context = e.context,
+          shape = context.shape,
+          labelTarget = context.labelTarget,
+          labelTargetIndex = context.labelTargetIndex;
 
-          spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
-        } else if (direction === 'e') {
-          minOrMax = start -
-            resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
-            resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
+      // restore labelTarget
+      if (labelTarget) {
+        add(labelTarget.labels, shape, labelTargetIndex);
 
-          spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
-        }
+        shape.labelTarget = labelTarget;
       }
     });
 
-    return spaceToolConstraints;
   }
 
-  function includes$2(array, item) {
-    return array.indexOf(item) !== -1;
-  }
+  e(LabelSupport, CommandInterceptor);
 
-  function isConnection$7(element) {
-    return !!element.waypoints;
-  }
+  LabelSupport.$inject = [
+    'injector',
+    'eventBus',
+    'modeling'
+  ];
 
-  function isLabel$2(element) {
-    return !!element.labelTarget;
+
+  /**
+   * Return a filtered list of elements that do not
+   * contain attached elements with hosts being part
+   * of the selection.
+   *
+   * @param  {Array<djs.model.Base>} elements
+   *
+   * @return {Array<djs.model.Base>} filtered
+   */
+  function removeLabels(elements) {
+
+    return filter(elements, function(element) {
+
+      // filter out labels that are move together
+      // with their label targets
+      return elements.indexOf(element.labelTarget) === -1;
+    });
   }
 
-  var MARKER_DRAGGING$1 = 'djs-dragging',
-      MARKER_RESIZING = 'djs-resizing';
+  var LabelSupportModule = {
+    __init__: [ 'labelSupport' ],
+    labelSupport: [ 'type', LabelSupport ]
+  };
 
-  var LOW_PRIORITY$3 = 250;
+  var LOW_PRIORITY$3 = 251,
+      HIGH_PRIORITY$3 = 1401;
 
-  var max = Math.max;
+  var MARKER_ATTACH$1 = 'attach-ok';
 
 
   /**
-   * Provides previews for selecting/moving/resizing shapes when creating/removing space.
+   * Adds the notion of attached elements to the modeler.
+   *
+   * Optionally depends on `diagram-js/lib/features/move` to render
+   * the attached elements during move preview.
+   *
+   * Optionally depends on `diagram-js/lib/features/label-support`
+   * to render attached labels during move preview.
    *
+   * @param {didi.Injector} injector
    * @param {EventBus} eventBus
-   * @param {ElementRegistry} elementRegistry
    * @param {Canvas} canvas
-   * @param {Styles} styles
+   * @param {Rules} rules
+   * @param {Modeling} modeling
    */
-  function SpaceToolPreview(
-      eventBus, elementRegistry, canvas,
-      styles, previewSupport) {
+  function AttachSupport(injector, eventBus, canvas, rules, modeling) {
 
-    function addPreviewGfx(collection, dragGroup) {
-      forEach$1(collection, function(element) {
-        previewSupport.addDragger(element, dragGroup);
+    CommandInterceptor.call(this, eventBus);
 
-        canvas.addMarker(element, MARKER_DRAGGING$1);
-      });
-    }
+    var movePreview = injector.get('movePreview', false);
 
-    // add crosshair
-    eventBus.on('spaceTool.selection.start', function(event) {
-      var space = canvas.getLayer('space'),
-          context = event.context;
 
-      var orientation = {
-        x: 'M 0,-10000 L 0,10000',
-        y: 'M -10000,0 L 10000,0'
-      };
+    // remove all the attached elements from the shapes to be validated
+    // add all the attached shapes to the overall list of moved shapes
+    eventBus.on('shape.move.start', HIGH_PRIORITY$3, function(e) {
 
-      var crosshairGroup = create$1('g');
-      attr(crosshairGroup, styles.cls('djs-crosshair-group', [ 'no-events' ]));
+      var context = e.context,
+          shapes = context.shapes,
+          validatedShapes = context.validatedShapes;
 
-      append(space, crosshairGroup);
+      context.shapes = addAttached(shapes);
 
-      // horizontal path
-      var pathX = create$1('path');
-      attr(pathX, 'd', orientation.x);
-      classes(pathX).add('djs-crosshair');
+      context.validatedShapes = removeAttached(validatedShapes);
+    });
 
-      append(crosshairGroup, pathX);
+    // add attachers to the visual's group
+    movePreview && eventBus.on('shape.move.start', LOW_PRIORITY$3, function(e) {
 
-      // vertical path
-      var pathY = create$1('path');
-      attr(pathY, 'd', orientation.y);
-      classes(pathY).add('djs-crosshair');
+      var context = e.context,
+          shapes = context.shapes,
+          attachers = getAttachers(shapes);
 
-      append(crosshairGroup, pathY);
+      forEach$1(attachers, function(attacher) {
+        movePreview.makeDraggable(context, attacher, true);
 
-      context.crosshairGroup = crosshairGroup;
+        forEach$1(attacher.labels, function(label) {
+          movePreview.makeDraggable(context, label, true);
+        });
+      });
     });
 
-    // update crosshair
-    eventBus.on('spaceTool.selection.move', function(event) {
-      var crosshairGroup = event.context.crosshairGroup;
+    // add attach-ok marker to current host
+    movePreview && eventBus.on('shape.move.start', function(event) {
+      var context = event.context,
+          shapes = context.shapes;
 
-      translate$2(crosshairGroup, event.x, event.y);
-    });
+      if (shapes.length !== 1) {
+        return;
+      }
 
-    // remove crosshair
-    eventBus.on('spaceTool.selection.cleanup', function(event) {
-      var context = event.context,
-          crosshairGroup = context.crosshairGroup;
+      var shape = shapes[0];
 
-      if (crosshairGroup) {
-        remove$1(crosshairGroup);
+      var host = shape.host;
+
+      if (host) {
+        canvas.addMarker(host, MARKER_ATTACH$1);
+
+        eventBus.once([
+          'shape.move.out',
+          'shape.move.cleanup'
+        ], function() {
+          canvas.removeMarker(host, MARKER_ATTACH$1);
+        });
       }
     });
 
-    // add and update move/resize previews
-    eventBus.on('spaceTool.move', LOW_PRIORITY$3, function(event) {
+    // add all attachers to move closure
+    this.preExecuted('elements.move', HIGH_PRIORITY$3, function(e) {
+      var context = e.context,
+          closure = context.closure,
+          shapes = context.shapes,
+          attachers = getAttachers(shapes);
 
-      var context = event.context,
-          line = context.line,
-          axis = context.axis,
-          movingShapes = context.movingShapes,
-          resizingShapes = context.resizingShapes;
+      forEach$1(attachers, function(attacher) {
+        closure.add(attacher, closure.topLevel[attacher.host.id]);
+      });
+    });
 
-      if (!context.initialized) {
+    // perform the attaching after shapes are done moving
+    this.postExecuted('elements.move', function(e) {
+
+      var context = e.context,
+          shapes = context.shapes,
+          newHost = context.newHost,
+          attachers;
+
+      // only single elements can be attached
+      // multiply elements can be detached
+      if (newHost && shapes.length !== 1) {
         return;
       }
 
-      if (!context.dragGroup) {
-        var spaceLayer = canvas.getLayer('space');
+      if (newHost) {
+        attachers = shapes;
+      } else {
 
-        line = create$1('path');
-        attr(line, 'd', 'M0,0 L0,0');
-        classes(line).add('djs-crosshair');
+        // find attachers moved without host
+        attachers = filter(shapes, function(shape) {
+          var host = shape.host;
 
-        append(spaceLayer, line);
+          return isAttacher(shape) && !includes$2(shapes, host);
+        });
+      }
 
-        context.line = line;
+      forEach$1(attachers, function(attacher) {
+        modeling.updateAttachment(attacher, newHost);
+      });
+    });
 
-        var dragGroup = create$1('g');
-        attr(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));
+    // ensure invalid attachment connections are removed
+    this.postExecuted('elements.move', function(e) {
 
-        append(canvas.getActiveLayer(), dragGroup);
+      var shapes = e.context.shapes;
 
-        // shapes
-        addPreviewGfx(movingShapes, dragGroup);
+      forEach$1(shapes, function(shape) {
 
-        // connections
-        var movingConnections = context.movingConnections = elementRegistry.filter(function(element) {
-          var sourceIsMoving = false;
+        forEach$1(shape.attachers, function(attacher) {
 
-          forEach$1(movingShapes, function(shape) {
-            forEach$1(shape.outgoing, function(connection) {
-              if (element === connection) {
-                sourceIsMoving = true;
-              }
+          // remove invalid outgoing connections
+          forEach$1(attacher.outgoing.slice(), function(connection) {
+            var allowed = rules.allowed('connection.reconnect', {
+              connection: connection,
+              source: connection.source,
+              target: connection.target
             });
-          });
-
-          var targetIsMoving = false;
 
-          forEach$1(movingShapes, function(shape) {
-            forEach$1(shape.incoming, function(connection) {
-              if (element === connection) {
-                targetIsMoving = true;
-              }
-            });
+            if (!allowed) {
+              modeling.removeConnection(connection);
+            }
           });
 
-          var sourceIsResizing = false;
-
-          forEach$1(resizingShapes, function(shape) {
-            forEach$1(shape.outgoing, function(connection) {
-              if (element === connection) {
-                sourceIsResizing = true;
-              }
+          // remove invalid incoming connections
+          forEach$1(attacher.incoming.slice(), function(connection) {
+            var allowed = rules.allowed('connection.reconnect', {
+              connection: connection,
+              source: connection.source,
+              target: connection.target
             });
-          });
-
-          var targetIsResizing = false;
 
-          forEach$1(resizingShapes, function(shape) {
-            forEach$1(shape.incoming, function(connection) {
-              if (element === connection) {
-                targetIsResizing = true;
-              }
-            });
+            if (!allowed) {
+              modeling.removeConnection(connection);
+            }
           });
-
-          return isConnection$6(element)
-            && (sourceIsMoving || sourceIsResizing)
-            && (targetIsMoving || targetIsResizing);
         });
+      });
+    });
 
+    this.postExecute('shape.create', function(e) {
+      var context = e.context,
+          shape = context.shape,
+          host = context.host;
 
-        addPreviewGfx(movingConnections, dragGroup);
-
-        context.dragGroup = dragGroup;
+      if (host) {
+        modeling.updateAttachment(shape, host);
       }
+    });
 
-      if (!context.frameGroup) {
-        var frameGroup = create$1('g');
-        attr(frameGroup, styles.cls('djs-frame-group', [ 'no-events' ]));
-
-        append(canvas.getActiveLayer(), frameGroup);
+    // update attachments if the host is replaced
+    this.postExecute('shape.replace', function(e) {
 
-        var frames = [];
+      var context = e.context,
+          oldShape = context.oldShape,
+          newShape = context.newShape;
 
-        forEach$1(resizingShapes, function(shape) {
-          var frame = previewSupport.addFrame(shape, frameGroup);
+      // move the attachers to the new host
+      saveClear(oldShape.attachers, function(attacher) {
+        var allowed = rules.allowed('elements.move', {
+          target: newShape,
+          shapes: [ attacher ]
+        });
 
-          var initialBounds = frame.getBBox();
+        if (allowed === 'attach') {
+          modeling.updateAttachment(attacher, newShape);
+        } else {
+          modeling.removeShape(attacher);
+        }
+      });
 
-          frames.push({
-            element: frame,
-            initialBounds: initialBounds
-          });
+      // move attachers if new host has different size
+      if (newShape.attachers.length) {
 
-          canvas.addMarker(shape, MARKER_RESIZING);
+        forEach$1(newShape.attachers, function(attacher) {
+          var delta = getNewAttachShapeDelta(attacher, oldShape, newShape);
+          modeling.moveShape(attacher, delta, attacher.parent);
         });
-
-        context.frameGroup = frameGroup;
-        context.frames = frames;
       }
 
-      var orientation = {
-        x: 'M' + event.x + ', -10000 L' + event.x + ', 10000',
-        y: 'M -10000, ' + event.y + ' L 10000, ' + event.y
-      };
-
-      attr(line, { d: orientation[ axis ] });
-
-      var opposite = { x: 'y', y: 'x' };
-      var delta = { x: event.dx, y: event.dy };
-      delta[ opposite[ context.axis ] ] = 0;
-
-      // update move previews
-      translate$2(context.dragGroup, delta.x, delta.y);
+    });
 
-      // update resize previews
-      forEach$1(context.frames, function(frame) {
-        var element = frame.element,
-            initialBounds = frame.initialBounds,
-            width,
-            height;
+    // move shape on host resize
+    this.postExecute('shape.resize', function(event) {
+      var context = event.context,
+          shape = context.shape,
+          oldBounds = context.oldBounds,
+          newBounds = context.newBounds,
+          attachers = shape.attachers,
+          hints = context.hints || {};
 
-        if (context.direction === 'e') {
-          attr(element, {
-            width: max(initialBounds.width + delta.x, 5)
-          });
-        } else {
-          width = max(initialBounds.width - delta.x, 5);
+      if (hints.attachSupport === false) {
+        return;
+      }
 
-          attr(element, {
-            width: width,
-            x: initialBounds.x + initialBounds.width - width
-          });
-        }
+      forEach$1(attachers, function(attacher) {
+        var delta = getNewAttachShapeDelta(attacher, oldBounds, newBounds);
 
-        if (context.direction === 's') {
-          attr(element, {
-            height: max(initialBounds.height + delta.y, 5)
-          });
-        } else {
-          height = max(initialBounds.height - delta.y, 5);
+        modeling.moveShape(attacher, delta, attacher.parent);
 
-          attr(element, {
-            height: height,
-            y: initialBounds.y + initialBounds.height - height
-          });
-        }
+        forEach$1(attacher.labels, function(label) {
+          modeling.moveShape(label, delta, label.parent);
+        });
       });
-
     });
 
-    // remove move/resize previews
-    eventBus.on('spaceTool.cleanup', function(event) {
-
-      var context = event.context,
-          movingShapes = context.movingShapes,
-          movingConnections = context.movingConnections,
-          resizingShapes = context.resizingShapes,
-          line = context.line,
-          dragGroup = context.dragGroup,
-          frameGroup = context.frameGroup;
-
-      // moving shapes
-      forEach$1(movingShapes, function(shape) {
-        canvas.removeMarker(shape, MARKER_DRAGGING$1);
-      });
-
-      // moving connections
-      forEach$1(movingConnections, function(connection) {
-        canvas.removeMarker(connection, MARKER_DRAGGING$1);
-      });
+    // remove attachments
+    this.preExecute('shape.delete', function(event) {
 
-      if (dragGroup) {
-        remove$1(line);
-        remove$1(dragGroup);
-      }
+      var shape = event.context.shape;
 
-      forEach$1(resizingShapes, function(shape) {
-        canvas.removeMarker(shape, MARKER_RESIZING);
+      saveClear(shape.attachers, function(attacher) {
+        modeling.removeShape(attacher);
       });
 
-      if (frameGroup) {
-        remove$1(frameGroup);
+      if (shape.host) {
+        modeling.updateAttachment(shape, null);
       }
     });
   }
 
-  SpaceToolPreview.$inject = [
+  e(AttachSupport, CommandInterceptor);
+
+  AttachSupport.$inject = [
+    'injector',
     'eventBus',
-    'elementRegistry',
     'canvas',
-    'styles',
-    'previewSupport'
+    'rules',
+    'modeling'
   ];
 
 
-  // helpers //////////////////////
+  /**
+   * Return attachers of the given shapes
+   *
+   * @param {Array<djs.model.Base>} shapes
+   * @return {Array<djs.model.Base>}
+   */
+  function getAttachers(shapes) {
+    return flatten(map$1(shapes, function(s) {
+      return s.attachers || [];
+    }));
+  }
 
   /**
-   * Checks if an element is a connection.
+   * Return a combined list of elements and
+   * attachers.
+   *
+   * @param {Array<djs.model.Base>} elements
+   * @return {Array<djs.model.Base>} filtered
    */
-  function isConnection$6(element) {
-    return element.waypoints;
+  function addAttached(elements) {
+    var attachers = getAttachers(elements);
+
+    return unionBy('id', elements, attachers);
   }
 
-  var SpaceToolModule = {
-    __init__: [ 'spaceToolPreview' ],
+  /**
+   * Return a filtered list of elements that do not
+   * contain attached elements with hosts being part
+   * of the selection.
+   *
+   * @param  {Array<djs.model.Base>} elements
+   *
+   * @return {Array<djs.model.Base>} filtered
+   */
+  function removeAttached(elements) {
+
+    var ids = groupBy(elements, 'id');
+
+    return filter(elements, function(element) {
+      while (element) {
+
+        // host in selection
+        if (element.host && ids[element.host.id]) {
+          return false;
+        }
+
+        element = element.parent;
+      }
+
+      return true;
+    });
+  }
+
+  function isAttacher(shape) {
+    return !!shape.host;
+  }
+
+  function includes$2(array, item) {
+    return array.indexOf(item) !== -1;
+  }
+
+  var AttachSupportModule = {
     __depends__: [
-      DraggingModule,
-      RulesModule$1,
-      ToolManagerModule,
-      PreviewSupportModule,
-      MouseModule
+      RulesModule$1
     ],
-    spaceTool: [ 'type', SpaceTool ],
-    spaceToolPreview: [ 'type', SpaceToolPreview ]
+    __init__: [ 'attachSupport' ],
+    attachSupport: [ 'type', AttachSupport ]
   };
 
   function BpmnFactory(moddle) {
@@ -53566,9 +53725,7 @@
           target = connection.target,
           waypoints = copyWaypoints(connection),
           axis = getAxisFromDirection(direction),
-          layoutHints = {
-            labelBehavior: false
-          };
+          layoutHints = {};
 
       if (includes$1(affectedShapes, source) && includes$1(affectedShapes, target)) {