camunda-bpmn-js 5.1.0 → 5.2.1

package/dist/camunda-cloud-modeler.development.js

@@ -2755,7 +2755,7 @@
    * @return {string}
    */
   function componentsToPath(elements) {
-    return elements.flat().join(',').replace(/,?([A-z]),?/g, '$1');
+    return elements.flat().join(',').replace(/,?([A-Za-z]),?/g, '$1');
   }
 
   /**
@@ -25387,7 +25387,7 @@
    * `keyboard.bind=true|false` configuration option.
    *
    * @param {Object} config
-   * @param {EventTarget} [config.bindTo]
+   * @param {boolean} [config.bind]
    * @param {EventBus} eventBus
    */
   function Keyboard(config, eventBus) {
@@ -25463,10 +25463,17 @@
   /**
    * Bind keyboard events to the given DOM node.
    *
+   * @overlord
+   * @deprecated No longer in use since version 15.0.0.
+   *
    * @param {EventTarget} node
    */
+  /**
+   * Bind keyboard events to the canvas node.
+   */
   Keyboard.prototype.bind = function(node) {
 
+    // legacy <node> argument provided
     if (node) {
       console.error('unsupported argument <node>', new Error(compatMessage));
     }
@@ -27770,7 +27777,7 @@
         return originalEntries;
       }
 
-      if (!value) {
+      if (!value.trim()) {
         return originalEntries.filter(({ rank = 0 }) => rank >= 0);
       }
 
@@ -28647,6 +28654,12 @@
       keys
     } = options;
 
+    pattern = pattern.trim().toLowerCase();
+
+    if (!pattern) {
+      throw new Error('<pattern> must not be empty');
+    }
+
     const words = pattern.trim().toLowerCase().split(/\s+/);
 
     return items.flatMap((item) => {
@@ -28774,22 +28787,33 @@
   }
 
   /**
-   * Score a token.
+   * Score a token based on its characteristics
+   * and the length of the matched content.
    *
    * @param { Token } token
    *
    * @returns { number }
    */
   function scoreToken(token) {
+    const modifier = Math.log(token.value.length);
+
     if (!token.match) {
-      return 0;
+      return -0.07 * modifier;
     }
 
-    return token.start
-      ? 1.37
-      : token.wordStart
-        ? 1.13
-        : 1;
+    return (
+      token.start
+        ? (
+          token.end
+            ? 131.9
+            : 7.87
+        )
+        : (
+          token.wordStart
+            ? 2.19
+            : 1
+        )
+    ) * modifier;
   }
 
   /**
@@ -28828,7 +28852,12 @@
     const tokens = [];
     const matchedWords = {};
 
-    const regexpString = words.map(escapeRegexp).flatMap(str => [ '(?<wordStart>\\b' + str + ')', str ]).join('|');
+    const wordsEscaped = words.map(escapeRegexp);
+
+    const regexpString = [
+      `(?<all>${wordsEscaped.join('\\s+')})`,
+      ...wordsEscaped
+    ].join('|');
 
     const regexp = new RegExp(regexpString, 'ig');
 
@@ -28839,6 +28868,17 @@
 
       const [ value ] = match;
 
+      const startIndex = match.index;
+      const endIndex = match.index + value.length;
+
+      const start = startIndex === 0;
+      const end = endIndex === string.length;
+
+      const all = !!match.groups.all;
+
+      const wordStart = start || /\s/.test(string.charAt(startIndex - 1));
+      const wordEnd = end || /\s/.test(string.charAt(endIndex + 1));
+
       if (match.index > lastIndex) {
 
         // add previous token (NO match)
@@ -28853,11 +28893,18 @@
         value,
         index: match.index,
         match: true,
-        wordStart: !!match.groups.wordStart,
-        start: match.index === 0
+        wordStart,
+        wordEnd,
+        start,
+        end,
+        all
       });
 
-      matchedWords[value.toLowerCase()] = true;
+      const newMatchedWords = all ? words : [ value ];
+
+      for (const word of newMatchedWords) {
+        matchedWords[word.toLowerCase()] = true;
+      }
 
       lastIndex = match.index + value.length;
     }
@@ -65058,7 +65105,7 @@
     this._clearResults();
 
     // do not search on empty query
-    if (!pattern || pattern === '') {
+    if (!pattern.trim()) {
       return;
     }
 
@@ -114579,7 +114626,7 @@
       this._tooltipConfig = tooltipConfig;
       this._feelPopupContainer = feelPopupContainer;
       this._getFeelPopupLinks = getFeelPopupLinks;
-      this._container = domify$1('<div style="height: 100%" class="bio-properties-panel-container"></div>');
+      this._container = domify$1('<div style="height: 100%" tabindex="-1" class="bio-properties-panel-container"></div>');
       var commandStack = injector.get('commandStack', false);
       commandStack && setupKeyboard(this._container, eventBus, commandStack);
       eventBus.on('diagram.init', () => {
@@ -122987,1450 +123034,1467 @@
     Modeler$1.prototype._extensionModules
   );
 
-  /**
-   * Get extension elements of business object. Optionally filter by type.
-   *
-   * @param  {djs.model.Base|ModdleElement} element
-   * @param  {String} [type=undefined]
-   * @returns {Array<ModdleElement>}
-   */
-  function getExtensionElementsList$1(element, type = undefined) {
-    const businessObject = getBusinessObject$2(element),
-          extensionElements = businessObject.get('extensionElements');
-
-    if (!extensionElements) {
-      return [];
-    }
-
-    const values = extensionElements.get('values');
-
-    if (!values || !values.length) {
-      return [];
-    }
-
-    if (type) {
-      return values.filter(value => is$5(value, type));
-    }
-
-    return values;
+  /**
+   * Get extension elements of business object. Optionally filter by type.
+   *
+   * @param  {djs.model.Base|ModdleElement} element
+   * @param  {String} [type=undefined]
+   * @returns {Array<ModdleElement>}
+   */
+  function getExtensionElementsList$1(element, type = undefined) {
+    const businessObject = getBusinessObject$2(element),
+          extensionElements = businessObject.get('extensionElements');
+
+    if (!extensionElements) {
+      return [];
+    }
+
+    const values = extensionElements.get('values');
+
+    if (!values || !values.length) {
+      return [];
+    }
+
+    if (type) {
+      return values.filter(value => is$5(value, type));
+    }
+
+    return values;
+  }
+
+  /**
+   * Remove one or more extension elements. Remove bpmn:ExtensionElements afterwards if it's empty.
+   *
+   * @param {ModdleElement} element
+   * @param {ModdleElement} businessObject
+   * @param {ModdleElement|Array<ModdleElement>} extensionElementsToRemove
+   * @param {CommandStack} commandStack
+   */
+  function removeExtensionElements(element, businessObject, extensionElementsToRemove, commandStack) {
+    if (!isArray$5(extensionElementsToRemove)) {
+      extensionElementsToRemove = [ extensionElementsToRemove ];
+    }
+
+    const extensionElements = businessObject.get('extensionElements'),
+          values = extensionElements.get('values').filter(value => !extensionElementsToRemove.includes(value));
+
+    commandStack.execute('element.updateModdleProperties', {
+      element,
+      moddleElement: extensionElements,
+      properties: {
+        values
+      }
+    });
   }
 
-  /**
-   * Remove one or more extension elements. Remove bpmn:ExtensionElements afterwards if it's empty.
-   *
-   * @param {ModdleElement} element
-   * @param {ModdleElement} businessObject
-   * @param {ModdleElement|Array<ModdleElement>} extensionElementsToRemove
-   * @param {CommandStack} commandStack
-   */
-  function removeExtensionElements(element, businessObject, extensionElementsToRemove, commandStack) {
-    if (!isArray$5(extensionElementsToRemove)) {
-      extensionElementsToRemove = [ extensionElementsToRemove ];
-    }
-
-    const extensionElements = businessObject.get('extensionElements'),
-          values = extensionElements.get('values').filter(value => !extensionElementsToRemove.includes(value));
-
-    commandStack.execute('element.updateModdleProperties', {
-      element,
-      moddleElement: extensionElements,
-      properties: {
-        values
-      }
-    });
+  const HIGH_PRIORITY$5 = 5000;
+
+
+  /**
+   * Zeebe BPMN behavior ensuring that bpmn:BusinessRuleTask only has one of the following:
+   *
+   * (1) zeebe:CalledDecision
+   * (2) zeebe:TaskDefinition and zeebe:TaskHeaders
+   */
+  class CleanUpBusinessRuleTaskBehavior extends CommandInterceptor$1 {
+    constructor(commandStack, eventBus) {
+      super(eventBus);
+
+      /**
+       * Remove zeebe:CalledDecision if zeebe:TaskDefinition is about to be added.
+       */
+      this.preExecute('element.updateModdleProperties' , HIGH_PRIORITY$5, function(context) {
+        const {
+          element,
+          moddleElement,
+          properties
+        } = context;
+
+        if (
+          !is$5(element, 'bpmn:BusinessRuleTask')
+          || !is$5(moddleElement, 'bpmn:ExtensionElements')
+          || !properties.values
+        ) {
+          return;
+        }
+
+        const calledDecision = getCalledDecision(element),
+              taskDefinition = getTaskDefinition(element);
+
+        if (
+          calledDecision
+          && !taskDefinition
+          && properties.values.find(value => is$5(value, 'zeebe:CalledDecision'))
+          && properties.values.find(value => is$5(value, 'zeebe:TaskDefinition'))
+        ) {
+          properties.values = without(properties.values, calledDecision);
+        }
+      }, true);
+
+      /**
+       * Remove zeebe:TaskDefinition and zeebe:TaskHeaders if zeebe:CalledDecision is about to be added.
+       */
+      this.preExecute('element.updateModdleProperties', HIGH_PRIORITY$5, function(context) {
+        const {
+          element,
+          moddleElement,
+          properties
+        } = context;
+
+        if (
+          !is$5(element, 'bpmn:BusinessRuleTask')
+          || !is$5(moddleElement, 'bpmn:ExtensionElements')
+          || !properties.values
+        ) {
+          return;
+        }
+
+        const calledDecision = getCalledDecision(element),
+              taskDefinition = getTaskDefinition(element),
+              taskHeaders = getTaskHeaders(element);
+
+        if (
+          !calledDecision
+          && (taskDefinition || taskHeaders)
+          && properties.values.find(value => is$5(value, 'zeebe:CalledDecision'))
+          && properties.values.find(value => is$5(value, 'zeebe:TaskDefinition') || is$5(value, 'zeebe:TaskHeaders'))
+        ) {
+          properties.values = without(properties.values, (value) => value === taskDefinition || value === taskHeaders);
+        }
+      }, true);
+
+    }
+  }
+
+  CleanUpBusinessRuleTaskBehavior.$inject = [
+    'commandStack',
+    'eventBus'
+  ];
+
+
+  // helpers //////////
+
+  function getCalledDecision(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    return getExtensionElementsList$1(businessObject, 'zeebe:CalledDecision')[ 0 ];
+  }
+
+  function getTaskDefinition(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    return getExtensionElementsList$1(businessObject, 'zeebe:TaskDefinition')[ 0 ];
+  }
+
+  function getTaskHeaders(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    return getExtensionElementsList$1(businessObject, 'zeebe:TaskHeaders')[ 0 ];
   }
 
-  const HIGH_PRIORITY$5 = 5000;
-
-
-  /**
-   * Zeebe BPMN behavior ensuring that bpmn:BusinessRuleTask only has one of the following:
-   *
-   * (1) zeebe:CalledDecision
-   * (2) zeebe:TaskDefinition and zeebe:TaskHeaders
-   */
-  class CleanUpBusinessRuleTaskBehavior extends CommandInterceptor$1 {
-    constructor(commandStack, eventBus) {
-      super(eventBus);
-
-      /**
-       * Remove zeebe:CalledDecision if zeebe:TaskDefinition is about to be added.
-       */
-      this.preExecute('element.updateModdleProperties' , HIGH_PRIORITY$5, function(context) {
-        const {
-          element,
-          moddleElement,
-          properties
-        } = context;
-
-        if (
-          !is$5(element, 'bpmn:BusinessRuleTask')
-          || !is$5(moddleElement, 'bpmn:ExtensionElements')
-          || !properties.values
-        ) {
-          return;
-        }
-
-        const calledDecision = getCalledDecision(element),
-              taskDefinition = getTaskDefinition(element);
-
-        if (
-          calledDecision
-          && !taskDefinition
-          && properties.values.find(value => is$5(value, 'zeebe:CalledDecision'))
-          && properties.values.find(value => is$5(value, 'zeebe:TaskDefinition'))
-        ) {
-          properties.values = without(properties.values, calledDecision);
-        }
-      }, true);
-
-      /**
-       * Remove zeebe:TaskDefinition and zeebe:TaskHeaders if zeebe:CalledDecision is about to be added.
-       */
-      this.preExecute('element.updateModdleProperties', HIGH_PRIORITY$5, function(context) {
-        const {
-          element,
-          moddleElement,
-          properties
-        } = context;
-
-        if (
-          !is$5(element, 'bpmn:BusinessRuleTask')
-          || !is$5(moddleElement, 'bpmn:ExtensionElements')
-          || !properties.values
-        ) {
-          return;
-        }
-
-        const calledDecision = getCalledDecision(element),
-              taskDefinition = getTaskDefinition(element),
-              taskHeaders = getTaskHeaders(element);
-
-        if (
-          !calledDecision
-          && (taskDefinition || taskHeaders)
-          && properties.values.find(value => is$5(value, 'zeebe:CalledDecision'))
-          && properties.values.find(value => is$5(value, 'zeebe:TaskDefinition') || is$5(value, 'zeebe:TaskHeaders'))
-        ) {
-          properties.values = without(properties.values, (value) => value === taskDefinition || value === taskHeaders);
-        }
-      }, true);
-
-    }
+  class CleanUpEndEventBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, modeling) {
+      super(eventBus);
+
+      this.postExecuted('shape.replace', function(event) {
+
+        const {
+          context
+        } = event;
+
+        const {
+          newShape
+        } = context;
+
+        if (!is$5(newShape, 'bpmn:EndEvent') || !getErrorEventDefinition(newShape)) {
+          return;
+        }
+
+        const ioMapping = getIoMapping(newShape);
+
+        if (!ioMapping) {
+          return;
+        }
+
+        const businessObject = getBusinessObject$2(newShape),
+              extensionElements = businessObject.get('extensionElements'),
+              values = without(extensionElements.get('values'), ioMapping);
+
+        modeling.updateModdleProperties(newShape, extensionElements, { values });
+      });
+    }
+  }
+
+  CleanUpEndEventBehavior.$inject = [
+    'eventBus',
+    'modeling'
+  ];
+
+  // helpers //////////
+
+  function getErrorEventDefinition(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    const eventDefinitions = businessObject.get('eventDefinitions') || [];
+
+    return find$2(eventDefinitions, function(definition) {
+      return is$5(definition, 'bpmn:ErrorEventDefinition');
+    });
+  }
+
+  function getIoMapping(element) {
+    const bo = getBusinessObject$2(element);
+
+    const extensionElements = bo.get('extensionElements');
+
+    if (!extensionElements) {
+      return null;
+    }
+
+    const values = extensionElements.get('values');
+
+    if (!values) {
+      return null;
+    }
+
+    return find$2(values, value => is$5(value, 'zeebe:IoMapping'));
   }
 
-  CleanUpBusinessRuleTaskBehavior.$inject = [
-    'commandStack',
-    'eventBus'
-  ];
-
-
-  // helpers //////////
-
-  function getCalledDecision(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    return getExtensionElementsList$1(businessObject, 'zeebe:CalledDecision')[ 0 ];
+  const DISALLOWED_START_LISTENER_TYPES = [
+    'bpmn:StartEvent',
+    'bpmn:BoundaryEvent'
+  ];
+
+  class CleanUpExecutionListenersBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, modeling) {
+      super(eventBus);
+
+      // remove execution listeners of disallowed type
+      this.postExecuted('shape.replace', function(event) {
+        const element = event.context.newShape;
+
+        const executionListenersContainer = getExecutionListenersContainer(element);
+        if (!executionListenersContainer) {
+          return;
+        }
+
+        const listeners = executionListenersContainer.get('listeners');
+        const newListeners = withoutDisallowedListeners$1(element, listeners);
+
+        if (newListeners.length !== listeners.length) {
+          modeling.updateModdleProperties(element, executionListenersContainer, { listeners: newListeners });
+        }
+      });
+
+      // remove empty execution listener container
+      this.postExecuted('element.updateModdleProperties', function(event) {
+        const {
+          element,
+          moddleElement
+        } = event.context;
+
+        if (!is$5(moddleElement, 'zeebe:ExecutionListeners')) {
+          return;
+        }
+
+        const listeners = moddleElement.get('listeners');
+        if (listeners.length) {
+          return;
+        }
+
+        const extensionElements = moddleElement.$parent;
+        modeling.updateModdleProperties(element, extensionElements, { values: without(extensionElements.get('values'), moddleElement) });
+      });
+    }
+  }
+
+  CleanUpExecutionListenersBehavior.$inject = [
+    'eventBus',
+    'modeling'
+  ];
+
+  // helpers //////////
+  function withoutDisallowedListeners$1(element, listeners) {
+    listeners = withoutDisallowedStartListeners(element, listeners);
+    listeners = withoutDisallowedEndListeners(element, listeners);
+
+    return listeners;
+  }
+
+  function withoutDisallowedStartListeners(element, listeners) {
+    if (isAny$1(element, DISALLOWED_START_LISTENER_TYPES)) {
+      return listeners.filter(listener => listener.eventType !== 'start');
+    }
+
+    return listeners;
+  }
+
+  function withoutDisallowedEndListeners(element, listeners) {
+    if (shouldRemoveEndListeners(element)) {
+      return listeners.filter(listener => listener.eventType !== 'end');
+    }
+
+    return listeners;
+  }
+
+  function shouldRemoveEndListeners(element) {
+    if (
+      is$5(element, 'bpmn:BoundaryEvent') && isCompensationEvent(element) ||
+      is$5(element, 'bpmn:EndEvent') && isErrorEvent(element) ||
+      is$5(element, 'bpmn:Gateway')
+    ) {
+      return true;
+    }
+  }
+
+  function isCompensationEvent(element) {
+    const eventDefinitions = getEventDefinitions(element);
+
+    return find$2(eventDefinitions, function(definition) {
+      return is$5(definition, 'bpmn:CompensateEventDefinition');
+    });
+  }
+
+  function isErrorEvent(element) {
+    const eventDefinitions = getEventDefinitions(element);
+
+    return find$2(eventDefinitions, function(definition) {
+      return is$5(definition, 'bpmn:ErrorEventDefinition');
+    });
+  }
+
+  function getEventDefinitions(element) {
+    const businessObject = getBusinessObject$2(element);
+    return businessObject.get('eventDefinitions') || [];
+  }
+
+  function getExecutionListenersContainer(element) {
+    return getExtensionElementsList$1(element, 'zeebe:ExecutionListeners')[0];
   }
 
-  function getTaskDefinition(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    return getExtensionElementsList$1(businessObject, 'zeebe:TaskDefinition')[ 0 ];
+  const ALLOWED_EVENT_TYPES = [ 'complete', 'assignment' ];
+
+  class CleanUpTaskListenersBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, modeling) {
+      super(eventBus);
+
+      // remove task listeners of disallowed type on shape replace
+      this.postExecuted('shape.replace', function(event) {
+        const element = event.context.newShape;
+
+        updateListeners(element, modeling);
+      });
+
+      // remove task listeners of disallowed type on user task properties update
+      this.postExecuted('element.updateModdleProperties', function(event) {
+        const element = event.context.element;
+
+        if (!is$5(element, 'bpmn:UserTask')) {
+          return;
+        }
+
+        updateListeners(element, modeling);
+      });
+
+      // remove empty task listener container
+      this.postExecuted('element.updateModdleProperties', function(event) {
+        const {
+          element,
+          moddleElement
+        } = event.context;
+
+        if (!is$5(moddleElement, 'zeebe:TaskListeners')) {
+          return;
+        }
+
+        const listeners = moddleElement.get('listeners');
+        if (listeners.length) {
+          return;
+        }
+
+        const extensionElements = moddleElement.$parent;
+        modeling.updateModdleProperties(element, extensionElements, { values: without(extensionElements.get('values'), moddleElement) });
+      });
+    }
+  }
+
+  CleanUpTaskListenersBehavior.$inject = [
+    'eventBus',
+    'modeling'
+  ];
+
+  // helpers //////////
+  function updateListeners(element, modeling) {
+    const taskListenersContainer = getTaskListenersContainer(element);
+    if (!taskListenersContainer) {
+      return;
+    }
+
+    const listeners = taskListenersContainer.get('listeners');
+    const newListeners = withoutDisallowedListeners(element, listeners);
+
+    if (newListeners.length !== listeners.length) {
+      modeling.updateModdleProperties(element, taskListenersContainer, { listeners: newListeners });
+    }
+  }
+
+  function withoutDisallowedListeners(element, listeners) {
+    return listeners.filter(listener => {
+      if (
+        !is$5(element, 'bpmn:UserTask') ||
+        !ALLOWED_EVENT_TYPES.includes(listener.eventType) ||
+        !hasZeebeTaskExtensionElement(element)
+      ) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+  function getTaskListenersContainer(element) {
+    return getExtensionElementsList$1(element, 'zeebe:TaskListeners')[0];
+  }
+
+  function hasZeebeTaskExtensionElement(element) {
+    return getExtensionElementsList$1(element, 'zeebe:UserTask').length > 0;
   }
 
-  function getTaskHeaders(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    return getExtensionElementsList$1(businessObject, 'zeebe:TaskHeaders')[ 0 ];
+  /**
+   * Zeebe BPMN behavior ensuring that zeebe:subscription is removed from bpmn:Message
+   * when it has no properties anymore.
+   */
+  class CleanUpSubscriptionBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, commandStack) {
+      super(eventBus);
+
+      this.postExecuted([
+        'element.updateProperties',
+        'element.updateModdleProperties'
+      ], context => {
+        const element = context.shape || context.newShape || context.element;
+
+        if (element.labelTarget) {
+          return;
+        }
+
+        if (!is$5(element, 'bpmn:Event')) {
+          return;
+        }
+
+        const messageEventDefinition = getMessageEventDefinition$1(element);
+
+        if (!messageEventDefinition) {
+          return;
+        }
+
+        const message = messageEventDefinition.get('messageRef');
+
+        if (!message) {
+          return;
+        }
+
+        const subscription = getSubscription(message);
+
+        if (!subscription) {
+          return;
+        }
+
+        if (!hasNoProperties(subscription)) {
+          return;
+        }
+
+        removeExtensionElements(element, message, subscription, commandStack);
+      }, true);
+    }
+  }
+
+  CleanUpSubscriptionBehavior.$inject = [
+    'eventBus',
+    'commandStack'
+  ];
+
+
+  // helpers //////////
+
+  function getMessageEventDefinition$1(event) {
+    const businessObject = getBusinessObject$2(event);
+
+    return businessObject.get('eventDefinitions').find(eventDefinition => {
+      return is$5(eventDefinition, 'bpmn:MessageEventDefinition');
+    });
+  }
+
+  function getSubscription(message) {
+    return getExtensionElementsList$1(message, 'zeebe:Subscription')[ 0 ];
+  }
+
+  function hasNoProperties(element) {
+    const descriptor = element.$descriptor;
+
+    return descriptor.properties.every(property => {
+      return element.get(property.name) === undefined;
+    });
   }
 
-  class CleanUpEndEventBehavior extends CommandInterceptor$1 {
-    constructor(eventBus, modeling) {
-      super(eventBus);
-
-      this.postExecuted('shape.replace', function(event) {
-
-        const {
-          context
-        } = event;
-
-        const {
-          newShape
-        } = context;
-
-        if (!is$5(newShape, 'bpmn:EndEvent') || !getErrorEventDefinition(newShape)) {
-          return;
-        }
-
-        const ioMapping = getIoMapping(newShape);
-
-        if (!ioMapping) {
-          return;
-        }
-
-        const businessObject = getBusinessObject$2(newShape),
-              extensionElements = businessObject.get('extensionElements'),
-              values = without(extensionElements.get('values'), ioMapping);
-
-        modeling.updateModdleProperties(newShape, extensionElements, { values });
-      });
-    }
+  function getTimerEventDefinition(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    return businessObject.get('eventDefinitions').find(eventDefinition => {
+      return is$5(eventDefinition, 'bpmn:TimerEventDefinition');
+    });
+  }
+
+  /**
+   * Check whether a given timer expression type is supported for a given element.
+   *
+   * @param {string} type
+   * @param {Element|ModdleElement} element
+   *
+   * @return {boolean}
+   */
+  function isTimerExpressionTypeSupported(type, element) {
+    const businessObject = getBusinessObject$2(element);
+
+    switch (type) {
+    case 'timeDate':
+      return isAny$1(element, [
+        'bpmn:BoundaryEvent',
+        'bpmn:IntermediateCatchEvent',
+        'bpmn:StartEvent'
+      ]);
+
+    case 'timeCycle':
+      if (is$5(element, 'bpmn:StartEvent') && (!hasParentEventSubProcess(businessObject)) || !isInterrupting(businessObject)) {
+        return true;
+      }
+
+      if (is$5(element, 'bpmn:BoundaryEvent') && !isInterrupting(businessObject)) {
+        return true;
+      }
+
+      return false;
+
+    case 'timeDuration':
+      if (isAny$1(element, [
+        'bpmn:BoundaryEvent',
+        'bpmn:IntermediateCatchEvent'
+      ])) {
+        return true;
+      }
+
+      if (is$5(element, 'bpmn:StartEvent') && hasParentEventSubProcess(businessObject)) {
+        return true;
+      }
+
+      return false;
+
+    default:
+      return false;
+    }
+  }
+
+  function isInterrupting(businessObject) {
+    if (is$5(businessObject, 'bpmn:BoundaryEvent')) {
+      return businessObject.get('cancelActivity') !== false;
+    }
+
+    return businessObject.get('isInterrupting') !== false;
+  }
+
+  function hasParentEventSubProcess(businessObject) {
+    const parent = businessObject.$parent;
+
+    return parent && is$5(parent, 'bpmn:SubProcess') && parent.get('triggeredByEvent');
   }
 
-  CleanUpEndEventBehavior.$inject = [
-    'eventBus',
-    'modeling'
+  /**
+   * Zeebe BPMN behavior ensuring that bpmn:TimerEventDefinition has only allowed time properties of:
+   * - timeCycle
+   * - timeDate
+   * - timeDuration
+   */
+  class CleanUpTimerExpressionBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, modeling) {
+      super(eventBus);
+
+      /**
+       * Remove unsupported timer expressions.
+       */
+      this.postExecuted([
+        'shape.move',
+        'shape.replace',
+        'element.updateProperties',
+        'element.updateModdleProperties'
+      ], context => {
+        const element = context.shape || context.newShape || context.element;
+
+        if (element.labelTarget) {
+          return;
+        }
+
+        if (!is$5(element, 'bpmn:Event')) {
+          return;
+        }
+
+        const timerEventDefinition = getTimerEventDefinition(element);
+
+        if (!timerEventDefinition) {
+          return;
+        }
+
+        const propertiesUpdate = {};
+
+        [
+          'timeCycle',
+          'timeDate',
+          'timeDuration'
+        ].forEach((type) => {
+          if (timerEventDefinition.get(type) && !isTimerExpressionTypeSupported(type, element)) {
+            propertiesUpdate[ type ] = undefined;
+          }
+        });
+
+        if (!Object.keys(propertiesUpdate).length) {
+          return;
+        }
+
+        modeling.updateModdleProperties(element, timerEventDefinition, propertiesUpdate);
+      }, true);
+    }
+  }
+
+  CleanUpTimerExpressionBehavior.$inject = [
+    'eventBus',
+    'modeling'
   ];
 
-  // helpers //////////
-
-  function getErrorEventDefinition(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    const eventDefinitions = businessObject.get('eventDefinitions') || [];
+  const WILDCARD = '*';
+
+  const TIMER_PROPERTIES = [
+    'timeCycle',
+    'timeDate',
+    'timeDuration'
+  ];
+
+  const zeebeServiceTaskProperties = [
+    'zeebe:Input',
+    'zeebe:LoopCharacteristics',
+    'zeebe:TaskDefinition',
+    'zeebe:TaskHeaders',
+    'zeebe:Subscription'
+  ];
+
+  class ZeebeModdleExtension {
+    constructor(eventBus) {
+      eventBus.on('moddleCopy.canCopyProperty', (context) => {
+        const {
+          parent,
+          property,
+          propertyName
+        } = context;
+
+        return this.canCopyProperty(property, parent, propertyName);
+      });
+    }
+
+    canCopyProperty(property, parent, propertyName) {
+
+      // (1) check if property is allowed in parent
+      if (isObject$1(property) && !isAllowedInParent(property, parent)) {
+        return false;
+      }
+
+      // (2) check for specific scenarios
+      if (!this.canHostServiceTaskLikeProperties(property, parent)) {
+        return false;
+      }
+
+      if (!this.canHostTimerExpression(property, parent, propertyName)) {
+        return false;
+      }
+    }
+
+    canHostServiceTaskLikeProperties(property, parent) {
+      if (isAllowedInZeebeServiceTask(property)) {
+        const serviceTaskLike = getParent(parent, 'bpmn:IntermediateThrowEvent') || getParent(parent, 'bpmn:EndEvent');
+
+        if (serviceTaskLike) {
+          return isMessageEvent(serviceTaskLike);
+        }
+      }
+
+      return true;
+    }
+
+    canHostTimerExpression(property, parent, propertyName) {
+      if (!is$5(parent, 'bpmn:TimerEventDefinition') || !TIMER_PROPERTIES.includes(propertyName)) {
+        return true;
+      }
+
+      return isTimerExpressionTypeSupported(propertyName, parent.$parent);
+    }
+  }
+
+  ZeebeModdleExtension.$inject = [ 'eventBus' ];
+
+
+  // helpers //////////
+
+  function getParent(element, type) {
+    if (!type) {
+      return element.$parent;
+    }
+
+    if (is$5(element, type)) {
+      return element;
+    }
+
+    if (!element.$parent) {
+      return;
+    }
+
+    return getParent(element.$parent, type);
+  }
+
+  function isAllowedInParent(property, parent) {
+
+    // (1) find property descriptor
+    const descriptor = property.$type && property.$model.getTypeDescriptor(property.$type);
+
+    const allowedIn = descriptor && descriptor.meta && descriptor.meta.allowedIn;
+
+    if (!allowedIn || isWildcard(allowedIn)) {
+      return true;
+    }
+
+    // (2) check if property has parent of allowed type
+    return some$1(allowedIn, function(type) {
+      return getParent(parent, type);
+    });
+  }
+
+  function isWildcard(allowedIn) {
+    return allowedIn.indexOf(WILDCARD) !== -1;
+  }
+
+  function isMessageEvent(event) {
+    const eventDefinitions = event.get('eventDefinitions');
+
+    return eventDefinitions.some((eventDefinition) => {
+      return is$5(eventDefinition, 'bpmn:MessageEventDefinition');
+    });
+  }
+
+  // check if property is allowed in zeebe:ZeebeServiceTask but not for none events
+  function isAllowedInZeebeServiceTask(property) {
+    return zeebeServiceTaskProperties.some((propertyType) => {
+      return is$5(property, propertyType);
+    });
+  }
 
-    return find$2(eventDefinitions, function(definition) {
-      return is$5(definition, 'bpmn:ErrorEventDefinition');
-    });
+  /**
+   * Creates a new element and set the parent to it
+   *
+   * @method ElementHelper#createElement
+   *
+   * @param {String} elementType of the new element
+   * @param {Object} properties of the new element in key-value pairs
+   * @param {moddle.object} parent of the new element
+   * @param {BpmnFactory} factory which creates the new element
+   *
+   * @returns {djs.model.Base} element which is created
+   */
+  function createElement$2(elementType, properties, parent, factory) {
+    var element = factory.create(elementType, properties);
+    element.$parent = parent;
+
+    return element;
   }
 
-  function getIoMapping(element) {
-    const bo = getBusinessObject$2(element);
-
-    const extensionElements = bo.get('extensionElements');
-
-    if (!extensionElements) {
-      return null;
-    }
-
-    const values = extensionElements.get('values');
-
-    if (!values) {
-      return null;
-    }
-
-    return find$2(values, value => is$5(value, 'zeebe:IoMapping'));
-  }
-
-  const DISALLOWED_START_LISTENER_TYPES = [
-    'bpmn:StartEvent',
-    'bpmn:BoundaryEvent'
-  ];
-
-  class CleanUpExecutionListenersBehavior extends CommandInterceptor$1 {
-    constructor(eventBus, modeling) {
-      super(eventBus);
-
-      // remove execution listeners of disallowed type
-      this.postExecuted('shape.replace', function(event) {
-        const element = event.context.newShape;
-
-        const executionListenersContainer = getExecutionListenersContainer(element);
-        if (!executionListenersContainer) {
-          return;
-        }
-
-        const listeners = executionListenersContainer.get('listeners');
-        const newListeners = withoutDisallowedListeners$1(element, listeners);
-
-        if (newListeners.length !== listeners.length) {
-          modeling.updateModdleProperties(element, executionListenersContainer, { listeners: newListeners });
-        }
-      });
-
-      // remove empty execution listener container
-      this.postExecuted('element.updateModdleProperties', function(event) {
-        const {
-          element,
-          moddleElement
-        } = event.context;
-
-        if (!is$5(moddleElement, 'zeebe:ExecutionListeners')) {
-          return;
-        }
-
-        const listeners = moddleElement.get('listeners');
-        if (listeners.length) {
-          return;
-        }
-
-        const extensionElements = moddleElement.$parent;
-        modeling.updateModdleProperties(element, extensionElements, { values: without(extensionElements.get('values'), moddleElement) });
-      });
-    }
-  }
-
-  CleanUpExecutionListenersBehavior.$inject = [
-    'eventBus',
-    'modeling'
-  ];
-
-  // helpers //////////
-  function withoutDisallowedListeners$1(element, listeners) {
-    listeners = withoutDisallowedStartListeners(element, listeners);
-    listeners = withoutDisallowedEndListeners(element, listeners);
-
-    return listeners;
-  }
-
-  function withoutDisallowedStartListeners(element, listeners) {
-    if (isAny$1(element, DISALLOWED_START_LISTENER_TYPES)) {
-      return listeners.filter(listener => listener.eventType !== 'start');
-    }
-
-    return listeners;
-  }
-
-  function withoutDisallowedEndListeners(element, listeners) {
-    if (shouldRemoveEndListeners(element)) {
-      return listeners.filter(listener => listener.eventType !== 'end');
-    }
-
-    return listeners;
-  }
-
-  function shouldRemoveEndListeners(element) {
-    if (
-      is$5(element, 'bpmn:BoundaryEvent') && isCompensationEvent(element) ||
-      is$5(element, 'bpmn:EndEvent') && isErrorEvent(element) ||
-      is$5(element, 'bpmn:Gateway')
-    ) {
-      return true;
-    }
-  }
-
-  function isCompensationEvent(element) {
-    const eventDefinitions = getEventDefinitions(element);
-
-    return find$2(eventDefinitions, function(definition) {
-      return is$5(definition, 'bpmn:CompensateEventDefinition');
-    });
-  }
-
-  function isErrorEvent(element) {
-    const eventDefinitions = getEventDefinitions(element);
-
-    return find$2(eventDefinitions, function(definition) {
-      return is$5(definition, 'bpmn:ErrorEventDefinition');
-    });
-  }
-
-  function getEventDefinitions(element) {
-    const businessObject = getBusinessObject$2(element);
-    return businessObject.get('eventDefinitions') || [];
-  }
-
-  function getExecutionListenersContainer(element) {
-    return getExtensionElementsList$1(element, 'zeebe:ExecutionListeners')[0];
-  }
-
-  const ALLOWED_EVENT_TYPES = [ 'complete', 'assignment' ];
-
-  class CleanUpTaskListenersBehavior extends CommandInterceptor$1 {
-    constructor(eventBus, modeling) {
-      super(eventBus);
-
-      // remove task listeners of disallowed type on shape replace
-      this.postExecuted('shape.replace', function(event) {
-        const element = event.context.newShape;
-
-        updateListeners(element, modeling);
-      });
-
-      // remove task listeners of disallowed type on user task properties update
-      this.postExecuted('element.updateModdleProperties', function(event) {
-        const element = event.context.element;
-
-        if (!is$5(element, 'bpmn:UserTask')) {
-          return;
-        }
-
-        updateListeners(element, modeling);
-      });
-
-      // remove empty task listener container
-      this.postExecuted('element.updateModdleProperties', function(event) {
-        const {
-          element,
-          moddleElement
-        } = event.context;
-
-        if (!is$5(moddleElement, 'zeebe:TaskListeners')) {
-          return;
-        }
-
-        const listeners = moddleElement.get('listeners');
-        if (listeners.length) {
-          return;
-        }
-
-        const extensionElements = moddleElement.$parent;
-        modeling.updateModdleProperties(element, extensionElements, { values: without(extensionElements.get('values'), moddleElement) });
-      });
-    }
-  }
-
-  CleanUpTaskListenersBehavior.$inject = [
-    'eventBus',
-    'modeling'
-  ];
-
-  // helpers //////////
-  function updateListeners(element, modeling) {
-    const taskListenersContainer = getTaskListenersContainer(element);
-    if (!taskListenersContainer) {
-      return;
-    }
-
-    const listeners = taskListenersContainer.get('listeners');
-    const newListeners = withoutDisallowedListeners(element, listeners);
-
-    if (newListeners.length !== listeners.length) {
-      modeling.updateModdleProperties(element, taskListenersContainer, { listeners: newListeners });
-    }
-  }
-
-  function withoutDisallowedListeners(element, listeners) {
-    return listeners.filter(listener => {
-      if (
-        !is$5(element, 'bpmn:UserTask') ||
-        !ALLOWED_EVENT_TYPES.includes(listener.eventType) ||
-        !hasZeebeTaskExtensionElement(element)
-      ) {
-        return false;
-      }
-      return true;
-    });
-  }
-
-  function getTaskListenersContainer(element) {
-    return getExtensionElementsList$1(element, 'zeebe:TaskListeners')[0];
-  }
-
-  function hasZeebeTaskExtensionElement(element) {
-    return getExtensionElementsList$1(element, 'zeebe:UserTask').length > 0;
-  }
-
-  /**
-   * Zeebe BPMN behavior ensuring that zeebe:subscription is removed from bpmn:Message
-   * when it has no properties anymore.
-   */
-  class CleanUpSubscriptionBehavior extends CommandInterceptor$1 {
-    constructor(eventBus, commandStack) {
-      super(eventBus);
-
-      this.postExecuted([
-        'element.updateProperties',
-        'element.updateModdleProperties'
-      ], context => {
-        const element = context.shape || context.newShape || context.element;
-
-        if (element.labelTarget) {
-          return;
-        }
-
-        if (!is$5(element, 'bpmn:Event')) {
-          return;
-        }
-
-        const messageEventDefinition = getMessageEventDefinition$1(element);
-
-        if (!messageEventDefinition) {
-          return;
-        }
-
-        const message = messageEventDefinition.get('messageRef');
-
-        if (!message) {
-          return;
-        }
-
-        const subscription = getSubscription(message);
-
-        if (!subscription) {
-          return;
-        }
-
-        if (!hasNoProperties(subscription)) {
-          return;
-        }
-
-        removeExtensionElements(element, message, subscription, commandStack);
-      }, true);
-    }
-  }
-
-  CleanUpSubscriptionBehavior.$inject = [
-    'eventBus',
-    'commandStack'
-  ];
-
-
-  // helpers //////////
-
-  function getMessageEventDefinition$1(event) {
-    const businessObject = getBusinessObject$2(event);
-
-    return businessObject.get('eventDefinitions').find(eventDefinition => {
-      return is$5(eventDefinition, 'bpmn:MessageEventDefinition');
-    });
-  }
-
-  function getSubscription(message) {
-    return getExtensionElementsList$1(message, 'zeebe:Subscription')[ 0 ];
-  }
-
-  function hasNoProperties(element) {
-    const descriptor = element.$descriptor;
-
-    return descriptor.properties.every(property => {
-      return element.get(property.name) === undefined;
-    });
-  }
-
-  function getTimerEventDefinition(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    return businessObject.get('eventDefinitions').find(eventDefinition => {
-      return is$5(eventDefinition, 'bpmn:TimerEventDefinition');
-    });
-  }
-
-  /**
-   * Check whether a given timer expression type is supported for a given element.
-   *
-   * @param {string} type
-   * @param {Element|ModdleElement} element
-   *
-   * @return {boolean}
-   */
-  function isTimerExpressionTypeSupported(type, element) {
-    const businessObject = getBusinessObject$2(element);
-
-    switch (type) {
-    case 'timeDate':
-      return isAny$1(element, [
-        'bpmn:BoundaryEvent',
-        'bpmn:IntermediateCatchEvent',
-        'bpmn:StartEvent'
-      ]);
-
-    case 'timeCycle':
-      if (is$5(element, 'bpmn:StartEvent') && (!hasParentEventSubProcess(businessObject)) || !isInterrupting(businessObject)) {
-        return true;
-      }
-
-      if (is$5(element, 'bpmn:BoundaryEvent') && !isInterrupting(businessObject)) {
-        return true;
-      }
-
-      return false;
-
-    case 'timeDuration':
-      if (isAny$1(element, [
-        'bpmn:BoundaryEvent',
-        'bpmn:IntermediateCatchEvent'
-      ])) {
-        return true;
-      }
-
-      if (is$5(element, 'bpmn:StartEvent') && hasParentEventSubProcess(businessObject)) {
-        return true;
-      }
-
-      return false;
-
-    default:
-      return false;
-    }
-  }
-
-  function isInterrupting(businessObject) {
-    if (is$5(businessObject, 'bpmn:BoundaryEvent')) {
-      return businessObject.get('cancelActivity') !== false;
-    }
-
-    return businessObject.get('isInterrupting') !== false;
-  }
-
-  function hasParentEventSubProcess(businessObject) {
-    const parent = businessObject.$parent;
-
-    return parent && is$5(parent, 'bpmn:SubProcess') && parent.get('triggeredByEvent');
-  }
-
-  /**
-   * Zeebe BPMN behavior ensuring that bpmn:TimerEventDefinition has only allowed time properties of:
-   * - timeCycle
-   * - timeDate
-   * - timeDuration
-   */
-  class CleanUpTimerExpressionBehavior extends CommandInterceptor$1 {
-    constructor(eventBus, modeling) {
-      super(eventBus);
-
-      /**
-       * Remove unsupported timer expressions.
-       */
-      this.postExecuted([
-        'shape.move',
-        'shape.replace',
-        'element.updateProperties',
-        'element.updateModdleProperties'
-      ], context => {
-        const element = context.shape || context.newShape || context.element;
-
-        if (element.labelTarget) {
-          return;
-        }
-
-        if (!is$5(element, 'bpmn:Event')) {
-          return;
-        }
-
-        const timerEventDefinition = getTimerEventDefinition(element);
-
-        if (!timerEventDefinition) {
-          return;
-        }
-
-        const propertiesUpdate = {};
-
-        [
-          'timeCycle',
-          'timeDate',
-          'timeDuration'
-        ].forEach((type) => {
-          if (timerEventDefinition.get(type) && !isTimerExpressionTypeSupported(type, element)) {
-            propertiesUpdate[ type ] = undefined;
-          }
-        });
-
-        if (!Object.keys(propertiesUpdate).length) {
-          return;
-        }
-
-        modeling.updateModdleProperties(element, timerEventDefinition, propertiesUpdate);
-      }, true);
-    }
-  }
-
-  CleanUpTimerExpressionBehavior.$inject = [
-    'eventBus',
-    'modeling'
-  ];
-
-  const WILDCARD = '*';
-
-  const TIMER_PROPERTIES = [
-    'timeCycle',
-    'timeDate',
-    'timeDuration'
-  ];
-
-  const zeebeServiceTaskProperties = [
-    'zeebe:Input',
-    'zeebe:LoopCharacteristics',
-    'zeebe:TaskDefinition',
-    'zeebe:TaskHeaders',
-    'zeebe:Subscription'
-  ];
-
-  class ZeebeModdleExtension {
-    constructor(eventBus) {
-      eventBus.on('moddleCopy.canCopyProperty', (context) => {
-        const {
-          parent,
-          property,
-          propertyName
-        } = context;
-
-        return this.canCopyProperty(property, parent, propertyName);
-      });
-    }
-
-    canCopyProperty(property, parent, propertyName) {
-
-      // (1) check if property is allowed in parent
-      if (isObject$1(property) && !isAllowedInParent(property, parent)) {
-        return false;
-      }
-
-      // (2) check for specific scenarios
-      if (!this.canHostServiceTaskLikeProperties(property, parent)) {
-        return false;
-      }
-
-      if (!this.canHostTimerExpression(property, parent, propertyName)) {
-        return false;
-      }
-    }
-
-    canHostServiceTaskLikeProperties(property, parent) {
-      if (isAllowedInZeebeServiceTask(property)) {
-        const serviceTaskLike = getParent(parent, 'bpmn:IntermediateThrowEvent') || getParent(parent, 'bpmn:EndEvent');
-
-        if (serviceTaskLike) {
-          return isMessageEvent(serviceTaskLike);
-        }
-      }
-
-      return true;
-    }
-
-    canHostTimerExpression(property, parent, propertyName) {
-      if (!is$5(parent, 'bpmn:TimerEventDefinition') || !TIMER_PROPERTIES.includes(propertyName)) {
-        return true;
-      }
-
-      return isTimerExpressionTypeSupported(propertyName, parent.$parent);
-    }
-  }
-
-  ZeebeModdleExtension.$inject = [ 'eventBus' ];
-
-
-  // helpers //////////
-
-  function getParent(element, type) {
-    if (!type) {
-      return element.$parent;
-    }
-
-    if (is$5(element, type)) {
-      return element;
-    }
-
-    if (!element.$parent) {
-      return;
-    }
-
-    return getParent(element.$parent, type);
-  }
-
-  function isAllowedInParent(property, parent) {
-
-    // (1) find property descriptor
-    const descriptor = property.$type && property.$model.getTypeDescriptor(property.$type);
-
-    const allowedIn = descriptor && descriptor.meta && descriptor.meta.allowedIn;
-
-    if (!allowedIn || isWildcard(allowedIn)) {
-      return true;
-    }
-
-    // (2) check if property has parent of allowed type
-    return some$1(allowedIn, function(type) {
-      return getParent(parent, type);
-    });
-  }
-
-  function isWildcard(allowedIn) {
-    return allowedIn.indexOf(WILDCARD) !== -1;
-  }
-
-  function isMessageEvent(event) {
-    const eventDefinitions = event.get('eventDefinitions');
-
-    return eventDefinitions.some((eventDefinition) => {
-      return is$5(eventDefinition, 'bpmn:MessageEventDefinition');
-    });
-  }
-
-  // check if property is allowed in zeebe:ZeebeServiceTask but not for none events
-  function isAllowedInZeebeServiceTask(property) {
-    return zeebeServiceTaskProperties.some((propertyType) => {
-      return is$5(property, propertyType);
-    });
-  }
-
-  /**
-   * Creates a new element and set the parent to it
-   *
-   * @method ElementHelper#createElement
-   *
-   * @param {String} elementType of the new element
-   * @param {Object} properties of the new element in key-value pairs
-   * @param {moddle.object} parent of the new element
-   * @param {BpmnFactory} factory which creates the new element
-   *
-   * @returns {djs.model.Base} element which is created
-   */
-  function createElement$2(elementType, properties, parent, factory) {
-    var element = factory.create(elementType, properties);
-    element.$parent = parent;
-
-    return element;
-  }
-
-  /**
-   * Get zeebe:CalledElement of an element.
-   *
-   * @param {djs.model.Base|ModdleElement} element
-   *
-   * @returns {ModdleElement}
-   */
-  function getCalledElement(element) {
-    const calledElements = getCalledElements(element);
-
-    return calledElements[ 0 ];
-  }
-
-  function getCalledElements(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    return getExtensionElementsList$1(businessObject, 'zeebe:CalledElement');
-  }
-
-  const HIGH_PRIORITY$4 = 5000;
-
-
-  /**
-   * Zeebe BPMN specific behavior for creating call activities.
-   */
-  class CreateZeebeCallActivityBehavior extends CommandInterceptor$1 {
-    constructor(bpmnFactory, eventBus, modeling) {
-      super(eventBus);
-
-      /**
-       * Add zeebe:CalledElement extension element with zeebe:propagateAllChildVariables attribute = false
-       * when creating bpmn:CallActivity.
-       */
-      this.postExecuted('shape.create', HIGH_PRIORITY$4, function(context) {
-        const { shape } = context;
-
-        if (!is$5(shape, 'bpmn:CallActivity')) {
-          return;
-        }
-
-        const businessObject = getBusinessObject$2(shape);
-
-        let calledElement = getCalledElement(businessObject);
-
-        if (!calledElement) {
-          let extensionElements = businessObject.get('extensionElements');
-
-          if (!extensionElements) {
-            extensionElements = createElement$2(
-              'bpmn:ExtensionElements',
-              {
-                values: []
-              },
-              businessObject,
-              bpmnFactory
-            );
-
-            modeling.updateProperties(shape, { extensionElements });
-          }
-
-          calledElement = createElement$2(
-            'zeebe:CalledElement',
-            {
-              propagateAllChildVariables: false
-            },
-            extensionElements,
-            bpmnFactory
-          );
-
-          modeling.updateModdleProperties(shape, extensionElements, {
-            values: [
-              ...(extensionElements.values || []),
-              calledElement
-            ]
-          });
-        } else if (!has$2(calledElement, 'propagateAllChildVariables')) {
-
-          // set zeebe:propagateAllChildVariables to false if zeebe:CalledElement exists
-          modeling.updateModdleProperties(shape, calledElement, {
-            propagateAllChildVariables: false
-          });
-        }
-      }, true);
-
-    }
-  }
-
-  CreateZeebeCallActivityBehavior.$inject = [
-    'bpmnFactory',
-    'eventBus',
-    'modeling'
-  ];
-
-  const LOW_PRIORITY$1 = 250;
-
-  /**
-   * Camunda-specific behavior ensuring `isExecutable` is kept after deleting
-   * the last participant.
-   */
-  class DeleteParticipantBehaviour extends CommandInterceptor$1 {
-    constructor(eventBus, canvas, modeling) {
-      super(eventBus);
-
-      this.postExecuted('shape.delete', LOW_PRIORITY$1, function(context) {
-        const {
-          collaborationRoot,
-          shape
-        } = context;
-
-        const newRoot = canvas.getRootElement();
-
-        if (is$5(shape, 'bpmn:Participant') &&
-            collaborationRoot &&
-            !collaborationRoot.businessObject.get('participants').length &&
-            is$5(newRoot, 'bpmn:Process')) {
-
-          const oldProcessBusinessObject = shape.businessObject.get('processRef');
-
-          if (!oldProcessBusinessObject) {
-            return;
-          }
-
-          modeling.updateProperties(newRoot, { isExecutable: oldProcessBusinessObject.get('isExecutable') });
-        }
-
-      }, true);
-    }
+  /**
+   * Get zeebe:CalledElement of an element.
+   *
+   * @param {djs.model.Base|ModdleElement} element
+   *
+   * @returns {ModdleElement}
+   */
+  function getCalledElement(element) {
+    const calledElements = getCalledElements(element);
+
+    return calledElements[ 0 ];
+  }
+
+  function getCalledElements(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    return getExtensionElementsList$1(businessObject, 'zeebe:CalledElement');
   }
 
-  DeleteParticipantBehaviour.$inject = [
-    'eventBus',
-    'canvas',
-    'modeling'
+  const HIGH_PRIORITY$4 = 5000;
+
+
+  /**
+   * Zeebe BPMN specific behavior for creating call activities.
+   */
+  class CreateZeebeCallActivityBehavior extends CommandInterceptor$1 {
+    constructor(bpmnFactory, eventBus, modeling) {
+      super(eventBus);
+
+      /**
+       * Add zeebe:CalledElement extension element with zeebe:propagateAllChildVariables attribute = false
+       * when creating bpmn:CallActivity.
+       */
+      this.postExecuted('shape.create', HIGH_PRIORITY$4, function(context) {
+        const { shape } = context;
+
+        if (!is$5(shape, 'bpmn:CallActivity')) {
+          return;
+        }
+
+        const businessObject = getBusinessObject$2(shape);
+
+        let calledElement = getCalledElement(businessObject);
+
+        if (!calledElement) {
+          let extensionElements = businessObject.get('extensionElements');
+
+          if (!extensionElements) {
+            extensionElements = createElement$2(
+              'bpmn:ExtensionElements',
+              {
+                values: []
+              },
+              businessObject,
+              bpmnFactory
+            );
+
+            modeling.updateProperties(shape, { extensionElements });
+          }
+
+          calledElement = createElement$2(
+            'zeebe:CalledElement',
+            {
+              propagateAllChildVariables: false
+            },
+            extensionElements,
+            bpmnFactory
+          );
+
+          modeling.updateModdleProperties(shape, extensionElements, {
+            values: [
+              ...(extensionElements.values || []),
+              calledElement
+            ]
+          });
+        } else if (!has$2(calledElement, 'propagateAllChildVariables')) {
+
+          // set zeebe:propagateAllChildVariables to false if zeebe:CalledElement exists
+          modeling.updateModdleProperties(shape, calledElement, {
+            propagateAllChildVariables: false
+          });
+        }
+      }, true);
+
+    }
+  }
+
+  CreateZeebeCallActivityBehavior.$inject = [
+    'bpmnFactory',
+    'eventBus',
+    'modeling'
   ];
 
-  const ids = new Ids$1([ 32, 32, 1 ]);
-
-  /**
-   * Get ID with prefix.
-   */
-  function getPrefixedId(prefix) {
-    return ids.nextPrefixed(prefix);
-  }
-
-  const FORM_KEY_PREFIX = 'camunda-forms:bpmn:',
-        USER_TASK_FORM_ID_PREFIX = 'UserTaskForm_';
-
-  function getFormDefinition(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    const formDefinitions = getExtensionElementsList$1(businessObject, 'zeebe:FormDefinition');
-
-    return formDefinitions[ 0 ];
-  }
-
-  function getUserTaskForm(element, options = {}) {
-    let {
-      formKey,
-      rootElement
-    } = options;
-
-    rootElement = rootElement || getRootElement$1(element);
-
-    if (!formKey) {
-      const formDefinition = getFormDefinition(element);
-
-      if (!formDefinition) {
-        return;
-      }
-
-      formKey = formDefinition.get('formKey');
-    }
-
-    const userTaskForms = getExtensionElementsList$1(rootElement, 'zeebe:UserTaskForm');
-
-    return userTaskForms.find(userTaskForm => {
-      return userTaskFormIdToFormKey(userTaskForm.get('id')) === formKey;
-    });
-  }
-
-  function userTaskFormIdToFormKey(userTaskFormId) {
-    return `${ FORM_KEY_PREFIX }${ userTaskFormId }`;
-  }
-
-  function isUserTaskFormKey(formKey) {
-    return formKey && formKey.startsWith(FORM_KEY_PREFIX);
-  }
-
-  function createUserTaskFormId() {
-    return getPrefixedId(USER_TASK_FORM_ID_PREFIX);
-  }
-
-  function getRootElement$1(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    let parent = businessObject;
-
-    while (parent.$parent && !is$5(parent, 'bpmn:Process')) {
-      parent = parent.$parent;
-    }
-
-    return parent;
-  }
-
-  /**
-   * Zeebe BPMN specific forms behavior.
-   */
-  class FormsBehavior extends CommandInterceptor$1 {
-    constructor(bpmnFactory, eventBus, modeling) {
-      super(eventBus);
-
-      this._modeling = modeling;
-
-      function removeUserTaskForm(element, moddleElement, userTaskForm) {
-        const extensionElements = moddleElement.get('extensionElements');
-
-        const values = without(extensionElements.get('values'), userTaskForm);
-
-        modeling.updateModdleProperties(element, extensionElements, {
-          values
-        });
-
-        if (!values.length) {
-          modeling.updateModdleProperties(element, moddleElement, {
-            extensionElements: undefined
-          });
-        }
-      }
-
-      /**
-       * Remove zeebe:UserTaskForm on user task removed.
-       */
-      this.postExecute('shape.delete', function(context) {
-        const {
-          oldParent,
-          shape
-        } = context;
-
-        const rootElement = getRootElement$1(oldParent);
-
-        const userTaskForm = getUserTaskForm(shape, { rootElement });
-
-        if (!is$5(shape, 'bpmn:UserTask') || !userTaskForm) {
-          return;
-        }
-
-        removeUserTaskForm(shape, rootElement, userTaskForm);
-      }, true);
-
-
-      /**
-       * Create new zeebe:FormDefinition and zeebe:UserTaskForm on user task created.
-       */
-      this.postExecute('shape.create', function(context) {
-        const { shape } = context;
-
-        const oldFormDefinition = getFormDefinition(shape);
-
-        if (!is$5(shape, 'bpmn:UserTask') || !oldFormDefinition) {
-          return;
-        }
-
-        const oldUserTaskForm = getUserTaskForm(shape);
-
-        const rootElement = getRootElement$1(shape);
-
-        const businessObject = getBusinessObject$2(shape);
-
-        const extensionElements = businessObject.get('extensionElements');
-
-        let rootExtensionElements = rootElement.get('extensionElements');
-
-        // (1) ensure extension elements exists
-        if (!rootExtensionElements) {
-          rootExtensionElements = createElement$2('bpmn:ExtensionElements', { values: [] }, rootElement, bpmnFactory);
-
-          modeling.updateModdleProperties(shape, rootElement, { extensionElements: rootExtensionElements });
-        }
-
-        // (2) remove existing form definition
-        let values = extensionElements.get('values').filter((element) => {
-          return element !== oldFormDefinition;
-        });
-
-        // (3) create new form definition
-        const userTaskFormId = createUserTaskFormId();
-
-        const newFormDefinition = createElement$2('zeebe:FormDefinition', {
-          formKey: userTaskFormIdToFormKey(userTaskFormId)
-        }, extensionElements, bpmnFactory);
-
-        values = [
-          ...values,
-          newFormDefinition
-        ];
-
-        modeling.updateModdleProperties(shape, extensionElements, {
-          values
-        });
-
-        // (4) create new user task form
-        const userTaskForm = createElement$2('zeebe:UserTaskForm', {
-          id: userTaskFormId,
-          body: oldUserTaskForm ? oldUserTaskForm.get('body') : ''
-        }, rootExtensionElements, bpmnFactory);
-
-        modeling.updateModdleProperties(shape, rootExtensionElements, {
-          values: [
-            ...(rootExtensionElements.get('values') || []),
-            userTaskForm
-          ]
-        });
-      }, true);
-
-
-      /**
-       * Ensure that a user task only has one of the following:
-       *
-       * 1. zeebe:FormDefinition with zeebe:formId (linked Camunda form)
-       * 2. zeebe:FormDefinition with zeebe:formKey in the format of camunda-forms:bpmn:UserTaskForm_1 (embedded Camunda form)
-       * 3. zeebe:FormDefinition with zeebe:formKey (custom form)
-       * 4. zeebe:FormDefinition with zeebe:externalReference (external form)
-       *
-       * Furthermore, ensure that:
-       *
-       * 1. zeebe:bindingType only exists if zeebe:formId is set (linked Camunda form)
-       */
-      this.preExecute('element.updateModdleProperties', function(context) {
-        const {
-          moddleElement,
-          properties
-        } = context;
-
-        if (is$5(moddleElement, 'zeebe:FormDefinition')) {
-          if ('formId' in properties) {
-            properties.formKey = undefined;
-            properties.externalReference = undefined;
-          } else if ('formKey' in properties) {
-            properties.formId = undefined;
-            properties.externalReference = undefined;
-            properties.bindingType = undefined;
-          } else if ('externalReference' in properties) {
-            properties.formId = undefined;
-            properties.formKey = undefined;
-            properties.bindingType = undefined;
-          }
-
-          if ('bindingType' in properties && !('formId' in properties) && !moddleElement.get('formId')) {
-            properties.externalReference = undefined;
-            properties.formId = '';
-            properties.formKey = undefined;
-          }
-        }
-      }, true);
-
-      /**
-       * Clean up user task form after form key or definition is removed. Clean up
-       * empty extension elements after form definition is removed.
-       */
-      this.postExecute('element.updateModdleProperties', function(context) {
-        const {
-          element,
-          moddleElement,
-          oldProperties
-        } = context;
-
-        if (is$5(moddleElement, 'zeebe:FormDefinition')) {
-          const formKey = moddleElement.get('formKey');
-
-          if (!formKey || !isUserTaskFormKey(formKey)) {
-            const userTaskForm = getUserTaskForm(element, { formKey: oldProperties.formKey });
-
-            if (userTaskForm) {
-              removeUserTaskForm(element, getRootElement$1(element), userTaskForm);
-            }
-          }
-        } else if (isExtensionElementRemoved(context, 'zeebe:FormDefinition')) {
-          const formDefinition = oldProperties.values.find(value => is$5(value, 'zeebe:FormDefinition'));
-
-          const userTaskForm = getUserTaskForm(element, { formKey: formDefinition.get('formKey') });
-
-          if (userTaskForm) {
-            removeUserTaskForm(element, getRootElement$1(element), userTaskForm);
-          }
-
-          if (!moddleElement.get('values').length) {
-            modeling.updateProperties(element, {
-              extensionElements: undefined
-            });
-          }
-        }
-      }, true);
-
-      this._registerZeebeUserTaskSupport();
-    }
-
-    _registerZeebeUserTaskSupport() {
-
-      /**
-       * Handle `formKey` for `zeebe:UserTask`.
-       * 1. Remove if embedded form is used.
-       * 2. Convert to externalReference if custom form key.
-       */
-      this.postExecute('element.updateModdleProperties', ({ element }) => {
-
-        if (!is$5(element, 'bpmn:UserTask') || !hasZeebeUserTask(element)) {
-          return;
-        }
-
-        const formDefinition = getFormDefinition(element);
-
-        if (!formDefinition) {
-          return;
-        }
-
-        const formKey = formDefinition.get('formKey');
-
-        if (isUndefined$5(formKey)) {
-          return;
-        }
-
-        if (isUserTaskFormKey(formKey)) {
-          this._modeling.updateModdleProperties(element, formDefinition, { formKey: undefined });
-        } else {
-          this._modeling.updateModdleProperties(element, formDefinition, {
-            externalReference: formKey
-          });
-        }
-      }, true);
-
-      /**
-       * Replace `externalReference` with `formKey` for non-`zeebe:UserTask`.
-       */
-      this.postExecute('element.updateModdleProperties', ({ element }) => {
-
-        if (!is$5(element, 'bpmn:UserTask') || hasZeebeUserTask(element)) {
-          return;
-        }
-
-        const formDefinition = getFormDefinition(element);
-
-        if (!formDefinition) {
-          return;
-        }
-
-        const externalReference = formDefinition.get('externalReference');
-
-        if (isUndefined$5(externalReference)) {
-          return;
-        }
-
-        this._modeling.updateModdleProperties(element, formDefinition, {
-          externalReference: undefined,
-          formKey: externalReference
-        });
-      }, true);
-    }
-  }
-
-  FormsBehavior.$inject = [
-    'bpmnFactory',
-    'eventBus',
-    'modeling'
+  const LOW_PRIORITY$1 = 250;
+
+  /**
+   * Camunda-specific behavior ensuring `isExecutable` is kept after deleting
+   * the last participant.
+   */
+  class DeleteParticipantBehaviour extends CommandInterceptor$1 {
+    constructor(eventBus, canvas, modeling) {
+      super(eventBus);
+
+      this.postExecuted('shape.delete', LOW_PRIORITY$1, function(context) {
+        const {
+          collaborationRoot,
+          shape
+        } = context;
+
+        const newRoot = canvas.getRootElement();
+
+        if (is$5(shape, 'bpmn:Participant') &&
+            collaborationRoot &&
+            !collaborationRoot.businessObject.get('participants').length &&
+            is$5(newRoot, 'bpmn:Process')) {
+
+          const oldProcessBusinessObject = shape.businessObject.get('processRef');
+
+          if (!oldProcessBusinessObject) {
+            return;
+          }
+
+          modeling.updateProperties(newRoot, { isExecutable: oldProcessBusinessObject.get('isExecutable') });
+        }
+
+      }, true);
+    }
+  }
+
+  DeleteParticipantBehaviour.$inject = [
+    'eventBus',
+    'canvas',
+    'modeling'
   ];
 
-  function isExtensionElementRemoved(context, type) {
-    const {
-      moddleElement,
-      oldProperties,
-      properties
-    } = context;
-
-    return is$5(moddleElement, 'bpmn:ExtensionElements')
-      && 'values' in oldProperties
-      && 'values' in properties
-      && oldProperties.values.find(value => is$5(value, type))
-      && !properties.values.find(value => is$5(value, type));
-  }
-
-  function hasZeebeUserTask(userTask) {
-    return getExtensionElementsList$1(userTask, 'zeebe:UserTask').length;
+  const ids = new Ids$1([ 32, 32, 1 ]);
+
+  /**
+   * Get ID with prefix.
+   */
+  function getPrefixedId(prefix) {
+    return ids.nextPrefixed(prefix);
   }
 
-  const HIGH_PRIORITY$3 = 5000;
-
-
-  /**
-   * Zeebe BPMN behavior removing zeebe:AssignmentDefinition elements without
-   * zeebe:assignee, zeebe:candidateGroups or zeebe:candidateUsers.
-   */
-  class RemoveAssignmentDefinitionBehavior extends CommandInterceptor$1 {
-    constructor(commandStack, eventBus) {
-      super(eventBus);
-
-      this.postExecuted('element.updateModdleProperties' , HIGH_PRIORITY$3, function(context) {
-        const {
-          element,
-          moddleElement
-        } = context;
-
-        if (!is$5(moddleElement, 'zeebe:AssignmentDefinition')) {
-          return;
-        }
-
-        const assignmentDefinition = moddleElement;
-
-        if (
-          is$5(element, 'bpmn:UserTask')
-            && isUndefined$5(assignmentDefinition.get('zeebe:assignee'))
-            && isUndefined$5(assignmentDefinition.get('zeebe:candidateGroups'))
-            && isUndefined$5(assignmentDefinition.get('zeebe:candidateUsers'))
-        ) {
-          const businessObject = getBusinessObject$2(element);
-
-          removeExtensionElements(element, businessObject, assignmentDefinition, commandStack);
-        }
-      }, true);
-
-    }
+  const FORM_KEY_PREFIX = 'camunda-forms:bpmn:',
+        USER_TASK_FORM_ID_PREFIX = 'UserTaskForm_';
+
+  function getFormDefinition(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    const formDefinitions = getExtensionElementsList$1(businessObject, 'zeebe:FormDefinition');
+
+    return formDefinitions[ 0 ];
+  }
+
+  function getUserTaskForm(element, options = {}) {
+    let {
+      formKey,
+      rootElement
+    } = options;
+
+    rootElement = rootElement || getRootElement$1(element);
+
+    if (!formKey) {
+      const formDefinition = getFormDefinition(element);
+
+      if (!formDefinition) {
+        return;
+      }
+
+      formKey = formDefinition.get('formKey');
+    }
+
+    const userTaskForms = getExtensionElementsList$1(rootElement, 'zeebe:UserTaskForm');
+
+    return userTaskForms.find(userTaskForm => {
+      return userTaskFormIdToFormKey(userTaskForm.get('id')) === formKey;
+    });
+  }
+
+  function userTaskFormIdToFormKey(userTaskFormId) {
+    return `${ FORM_KEY_PREFIX }${ userTaskFormId }`;
+  }
+
+  function formKeyToUserTaskFormId(formKey) {
+    return formKey.replace(FORM_KEY_PREFIX, '');
+  }
+
+  function isUserTaskFormKey(formKey) {
+    return formKey && formKey.startsWith(FORM_KEY_PREFIX);
+  }
+
+  function createUserTaskFormId() {
+    return getPrefixedId(USER_TASK_FORM_ID_PREFIX);
+  }
+
+  function getRootElement$1(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    let parent = businessObject;
+
+    while (parent.$parent && !is$5(parent, 'bpmn:Process')) {
+      parent = parent.$parent;
+    }
+
+    return parent;
   }
 
-  RemoveAssignmentDefinitionBehavior.$inject = [
-    'commandStack',
-    'eventBus'
-  ];
-
-  const HIGH_PRIORITY$2 = 5000;
-
-
-  /**
-   * Zeebe BPMN behavior removing zeebe:TaskSchedule elements without
-   * zeebe:dueDate and zeebe:followUpDate.
-   */
-  class RemoveTaskScheduleBehavior extends CommandInterceptor$1 {
-    constructor(commandStack, eventBus) {
-      super(eventBus);
-
-      this.postExecuted('element.updateModdleProperties' , HIGH_PRIORITY$2, function(context) {
-        const {
-          element,
-          moddleElement
-        } = context;
-
-        if (!is$5(moddleElement, 'zeebe:TaskSchedule')) {
-          return;
-        }
-
-        const taskSchedule = moddleElement;
-
-        if (
-          is$5(element, 'bpmn:UserTask')
-            && isUndefined$5(taskSchedule.get('zeebe:dueDate'))
-            && isUndefined$5(taskSchedule.get('zeebe:followUpDate'))
-        ) {
-          const businessObject = getBusinessObject$2(element);
-
-          removeExtensionElements(element, businessObject, taskSchedule, commandStack);
-        }
-      }, true);
-
-    }
+  /**
+   * Zeebe BPMN specific forms behavior.
+   */
+  class FormsBehavior extends CommandInterceptor$1 {
+    constructor(bpmnFactory, elementRegistry, eventBus, modeling) {
+      super(eventBus);
+
+      this._modeling = modeling;
+
+      function removeUserTaskForm(element, moddleElement, userTaskForm) {
+        const extensionElements = moddleElement.get('extensionElements');
+
+        const values = without(extensionElements.get('values'), userTaskForm);
+
+        modeling.updateModdleProperties(element, extensionElements, {
+          values
+        });
+
+        if (!values.length) {
+          modeling.updateModdleProperties(element, moddleElement, {
+            extensionElements: undefined
+          });
+        }
+      }
+
+      /**
+       * Remove zeebe:UserTaskForm on user task removed.
+       */
+      this.postExecute('shape.delete', function(context) {
+        const {
+          oldParent,
+          shape
+        } = context;
+
+        const rootElement = getRootElement$1(oldParent);
+
+        const userTaskForm = getUserTaskForm(shape, { rootElement });
+
+        if (!is$5(shape, 'bpmn:UserTask') || !userTaskForm) {
+          return;
+        }
+
+        removeUserTaskForm(shape, rootElement, userTaskForm);
+      }, true);
+
+
+      /**
+       * Create and reference new zeebe:UserTaskForm when user task is created
+       * that references existing zeebe:UserTaskForm that is already referenced by
+       * existing user task.
+       */
+      this.postExecute('shape.create', function(context) {
+        const { shape } = context;
+
+        if (!is$5(shape, 'bpmn:UserTask')) {
+          return;
+        }
+
+        const oldFormDefinition = getFormDefinition(shape);
+
+        if (!oldFormDefinition) {
+          return;
+        }
+
+        const oldUserTaskForm = getUserTaskForm(shape);
+
+        if (!oldUserTaskForm) {
+          return;
+        }
+
+        const isReferenced = elementRegistry.filter(element => {
+          if (element === shape) {
+            return false;
+          }
+
+          const formDefinition = getFormDefinition(element);
+
+          return formDefinition
+            && formDefinition.get('formKey')
+            && formKeyToUserTaskFormId(formDefinition.get('formKey')) === oldUserTaskForm.get('id');
+        });
+
+        if (!isReferenced.length) {
+          return;
+        }
+
+        const rootElement = getRootElement$1(shape);
+
+        let extensionElements = rootElement.get('extensionElements');
+
+        // (1) ensure extension elements exist
+        if (!extensionElements) {
+          extensionElements = createElement$2('bpmn:ExtensionElements', {
+            values: []
+          }, rootElement, bpmnFactory);
+
+          modeling.updateModdleProperties(shape, rootElement, {
+            extensionElements
+          });
+        }
+
+        // (2) create new user task form
+        const userTaskFormId = createUserTaskFormId();
+
+        const userTaskForm = createElement$2('zeebe:UserTaskForm', {
+          id: userTaskFormId,
+          body: oldUserTaskForm.get('body')
+        }, extensionElements, bpmnFactory);
+
+        modeling.updateModdleProperties(shape, extensionElements, {
+          values: [
+            ...(extensionElements.get('values') || []),
+            userTaskForm
+          ]
+        });
+
+        // (3) reference new user task form
+        modeling.updateModdleProperties(shape, oldFormDefinition, {
+          formKey: userTaskFormIdToFormKey(userTaskFormId)
+        });
+      }, true);
+
+
+      /**
+       * Ensure that a user task only has one of the following:
+       *
+       * 1. zeebe:FormDefinition with zeebe:formId (linked Camunda form)
+       * 2. zeebe:FormDefinition with zeebe:formKey in the format of camunda-forms:bpmn:UserTaskForm_1 (embedded Camunda form)
+       * 3. zeebe:FormDefinition with zeebe:formKey (custom form)
+       * 4. zeebe:FormDefinition with zeebe:externalReference (external form)
+       *
+       * Furthermore, ensure that:
+       *
+       * 1. zeebe:bindingType only exists if zeebe:formId is set (linked Camunda form)
+       */
+      this.preExecute('element.updateModdleProperties', function(context) {
+        const {
+          moddleElement,
+          properties
+        } = context;
+
+        if (is$5(moddleElement, 'zeebe:FormDefinition')) {
+          if ('formId' in properties) {
+            properties.formKey = undefined;
+            properties.externalReference = undefined;
+          } else if ('formKey' in properties) {
+            properties.formId = undefined;
+            properties.externalReference = undefined;
+            properties.bindingType = undefined;
+          } else if ('externalReference' in properties) {
+            properties.formId = undefined;
+            properties.formKey = undefined;
+            properties.bindingType = undefined;
+          }
+
+          if ('bindingType' in properties && !('formId' in properties) && !moddleElement.get('formId')) {
+            properties.externalReference = undefined;
+            properties.formId = '';
+            properties.formKey = undefined;
+          }
+        }
+      }, true);
+
+      /**
+       * Clean up user task form after form key or definition is removed. Clean up
+       * empty extension elements after form definition is removed.
+       */
+      this.postExecute('element.updateModdleProperties', function(context) {
+        const {
+          element,
+          moddleElement,
+          oldProperties
+        } = context;
+
+        if (is$5(moddleElement, 'zeebe:FormDefinition')) {
+          const formKey = moddleElement.get('formKey');
+
+          if (!formKey || !isUserTaskFormKey(formKey)) {
+            const userTaskForm = getUserTaskForm(element, { formKey: oldProperties.formKey });
+
+            if (userTaskForm) {
+              removeUserTaskForm(element, getRootElement$1(element), userTaskForm);
+            }
+          }
+        } else if (isExtensionElementRemoved(context, 'zeebe:FormDefinition')) {
+          const formDefinition = oldProperties.values.find(value => is$5(value, 'zeebe:FormDefinition'));
+
+          const userTaskForm = getUserTaskForm(element, { formKey: formDefinition.get('formKey') });
+
+          if (userTaskForm) {
+            removeUserTaskForm(element, getRootElement$1(element), userTaskForm);
+          }
+
+          if (!moddleElement.get('values').length) {
+            modeling.updateProperties(element, {
+              extensionElements: undefined
+            });
+          }
+        }
+      }, true);
+
+      this._registerZeebeUserTaskSupport();
+    }
+
+    _registerZeebeUserTaskSupport() {
+
+      /**
+       * Handle `formKey` for `zeebe:UserTask`.
+       * 1. Remove if embedded form is used.
+       * 2. Convert to externalReference if custom form key.
+       */
+      this.postExecute('element.updateModdleProperties', ({ element }) => {
+
+        if (!is$5(element, 'bpmn:UserTask') || !hasZeebeUserTask(element)) {
+          return;
+        }
+
+        const formDefinition = getFormDefinition(element);
+
+        if (!formDefinition) {
+          return;
+        }
+
+        const formKey = formDefinition.get('formKey');
+
+        if (isUndefined$5(formKey)) {
+          return;
+        }
+
+        if (isUserTaskFormKey(formKey)) {
+          this._modeling.updateModdleProperties(element, formDefinition, { formKey: undefined });
+        } else {
+          this._modeling.updateModdleProperties(element, formDefinition, {
+            externalReference: formKey
+          });
+        }
+      }, true);
+
+      /**
+       * Replace `externalReference` with `formKey` for non-`zeebe:UserTask`.
+       */
+      this.postExecute('element.updateModdleProperties', ({ element }) => {
+
+        if (!is$5(element, 'bpmn:UserTask') || hasZeebeUserTask(element)) {
+          return;
+        }
+
+        const formDefinition = getFormDefinition(element);
+
+        if (!formDefinition) {
+          return;
+        }
+
+        const externalReference = formDefinition.get('externalReference');
+
+        if (isUndefined$5(externalReference)) {
+          return;
+        }
+
+        this._modeling.updateModdleProperties(element, formDefinition, {
+          externalReference: undefined,
+          formKey: externalReference
+        });
+      }, true);
+    }
+  }
+
+  FormsBehavior.$inject = [
+    'bpmnFactory',
+    'elementRegistry',
+    'eventBus',
+    'modeling'
+  ];
+
+  function isExtensionElementRemoved(context, type) {
+    const {
+      moddleElement,
+      oldProperties,
+      properties
+    } = context;
+
+    return is$5(moddleElement, 'bpmn:ExtensionElements')
+      && 'values' in oldProperties
+      && 'values' in properties
+      && oldProperties.values.find(value => is$5(value, type))
+      && !properties.values.find(value => is$5(value, type));
+  }
+
+  function hasZeebeUserTask(userTask) {
+    return getExtensionElementsList$1(userTask, 'zeebe:UserTask').length;
   }
 
-  RemoveTaskScheduleBehavior.$inject = [
-    'commandStack',
-    'eventBus'
+  const HIGH_PRIORITY$3 = 5000;
+
+
+  /**
+   * Zeebe BPMN behavior removing zeebe:AssignmentDefinition elements without
+   * zeebe:assignee, zeebe:candidateGroups or zeebe:candidateUsers.
+   */
+  class RemoveAssignmentDefinitionBehavior extends CommandInterceptor$1 {
+    constructor(commandStack, eventBus) {
+      super(eventBus);
+
+      this.postExecuted('element.updateModdleProperties' , HIGH_PRIORITY$3, function(context) {
+        const {
+          element,
+          moddleElement
+        } = context;
+
+        if (!is$5(moddleElement, 'zeebe:AssignmentDefinition')) {
+          return;
+        }
+
+        const assignmentDefinition = moddleElement;
+
+        if (
+          is$5(element, 'bpmn:UserTask')
+            && isUndefined$5(assignmentDefinition.get('zeebe:assignee'))
+            && isUndefined$5(assignmentDefinition.get('zeebe:candidateGroups'))
+            && isUndefined$5(assignmentDefinition.get('zeebe:candidateUsers'))
+        ) {
+          const businessObject = getBusinessObject$2(element);
+
+          removeExtensionElements(element, businessObject, assignmentDefinition, commandStack);
+        }
+      }, true);
+
+    }
+  }
+
+  RemoveAssignmentDefinitionBehavior.$inject = [
+    'commandStack',
+    'eventBus'
   ];
 
-  /**
-   * Zeebe BPMN specific version tag behavior.
-   */
-  class VersionTagBehavior extends CommandInterceptor$1 {
-    constructor(eventBus, commandStack) {
-      super(eventBus);
-
-      /**
-       * Ensure that `zeebe:BindingTypeSupported` (`zeebe:CalledDecision`,
-       * `zeebe:CalledElement` and `zeebe:FormDefinition`) only has
-       * `zeebe:versionTag` if `zeebe:bindingType` is `versionTag`.
-       */
-      this.preExecute('element.updateModdleProperties', function(context) {
-        const {
-          moddleElement,
-          properties
-        } = context;
-
-        if (!isAny$1(moddleElement, [
-          'zeebe:CalledDecision',
-          'zeebe:CalledElement',
-          'zeebe:FormDefinition'
-        ])) {
-          return;
-        }
-
-        // unset `zeebe:versionTag` if `zeebe:bindingType` is not set to `versionTag`
-        if ('bindingType' in properties
-          && properties.bindingType !== 'versionTag'
-          && isDefined(moddleElement.get('versionTag'))) {
-          properties.versionTag = undefined;
-        }
-
-        // set `zeebe:bindingType` to `versionTag` if `zeebe:versionTag` is set
-        if ('versionTag' in properties && moddleElement.get('bindingType') !== 'versionTag') {
-          properties.bindingType = 'versionTag';
-        }
-      }, true);
-
-      /**
-       * Remove `zeebe:VersionTag` if its value is empty.
-       */
-      this.postExecuted('element.updateModdleProperties', function(context) {
-        const {
-          element,
-          moddleElement
-        } = context;
-
-        if (!is$5(moddleElement, 'zeebe:VersionTag')) {
-          return;
-        }
-
-        if (isEmpty$1(moddleElement.get('value'))) {
-          removeExtensionElements(element, getBusinessObject$2(element), moddleElement, commandStack);
-        }
-      }, true);
-    }
-  }
-
-  VersionTagBehavior.$inject = [
-    'eventBus',
-    'commandStack'
+  const HIGH_PRIORITY$2 = 5000;
+
+
+  /**
+   * Zeebe BPMN behavior removing zeebe:TaskSchedule elements without
+   * zeebe:dueDate and zeebe:followUpDate.
+   */
+  class RemoveTaskScheduleBehavior extends CommandInterceptor$1 {
+    constructor(commandStack, eventBus) {
+      super(eventBus);
+
+      this.postExecuted('element.updateModdleProperties' , HIGH_PRIORITY$2, function(context) {
+        const {
+          element,
+          moddleElement
+        } = context;
+
+        if (!is$5(moddleElement, 'zeebe:TaskSchedule')) {
+          return;
+        }
+
+        const taskSchedule = moddleElement;
+
+        if (
+          is$5(element, 'bpmn:UserTask')
+            && isUndefined$5(taskSchedule.get('zeebe:dueDate'))
+            && isUndefined$5(taskSchedule.get('zeebe:followUpDate'))
+        ) {
+          const businessObject = getBusinessObject$2(element);
+
+          removeExtensionElements(element, businessObject, taskSchedule, commandStack);
+        }
+      }, true);
+
+    }
+  }
+
+  RemoveTaskScheduleBehavior.$inject = [
+    'commandStack',
+    'eventBus'
   ];
 
-  // helpers //////////
-
-  function isEmpty$1(value) {
-    return value == undefined || value === '';
+  /**
+   * Zeebe BPMN specific version tag behavior.
+   */
+  class VersionTagBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, commandStack) {
+      super(eventBus);
+
+      /**
+       * Ensure that `zeebe:BindingTypeSupported` (`zeebe:CalledDecision`,
+       * `zeebe:CalledElement` and `zeebe:FormDefinition`) only has
+       * `zeebe:versionTag` if `zeebe:bindingType` is `versionTag`.
+       */
+      this.preExecute('element.updateModdleProperties', function(context) {
+        const {
+          moddleElement,
+          properties
+        } = context;
+
+        if (!isAny$1(moddleElement, [
+          'zeebe:CalledDecision',
+          'zeebe:CalledElement',
+          'zeebe:FormDefinition'
+        ])) {
+          return;
+        }
+
+        // unset `zeebe:versionTag` if `zeebe:bindingType` is not set to `versionTag`
+        if ('bindingType' in properties
+          && properties.bindingType !== 'versionTag'
+          && isDefined(moddleElement.get('versionTag'))) {
+          properties.versionTag = undefined;
+        }
+
+        // set `zeebe:bindingType` to `versionTag` if `zeebe:versionTag` is set
+        if ('versionTag' in properties && moddleElement.get('bindingType') !== 'versionTag') {
+          properties.bindingType = 'versionTag';
+        }
+      }, true);
+
+      /**
+       * Remove `zeebe:VersionTag` if its value is empty.
+       */
+      this.postExecuted('element.updateModdleProperties', function(context) {
+        const {
+          element,
+          moddleElement
+        } = context;
+
+        if (!is$5(moddleElement, 'zeebe:VersionTag')) {
+          return;
+        }
+
+        if (isEmpty$1(moddleElement.get('value'))) {
+          removeExtensionElements(element, getBusinessObject$2(element), moddleElement, commandStack);
+        }
+      }, true);
+    }
+  }
+
+  VersionTagBehavior.$inject = [
+    'eventBus',
+    'commandStack'
+  ];
+
+  // helpers //////////
+
+  function isEmpty$1(value) {
+    return value == undefined || value === '';
   }
 
-  var behaviorsModule = {
-    __init__: [
-      'cleanUpBusinessRuleTaskBehavior',
-      'cleanUpEndEventBehavior',
-      'cleanUpExecutionListenersBehavior',
-      'cleanUpTaskListenersBehavior',
-      'cleanUpSubscriptionBehavior',
-      'cleanUpTimerExpressionBehavior',
-      'copyPasteBehavior',
-      'createZeebeCallActivityBehavior',
-      'deleteParticipantBehaviour',
-      'formsBehavior',
-      'removeAssignmentDefinitionBehavior',
-      'removeTaskScheduleBehavior',
-      'versionTagBehavior'
-    ],
-    cleanUpBusinessRuleTaskBehavior: [ 'type', CleanUpBusinessRuleTaskBehavior ],
-    cleanUpEndEventBehavior: [ 'type', CleanUpEndEventBehavior ],
-    cleanUpExecutionListenersBehavior: [ 'type', CleanUpExecutionListenersBehavior ],
-    cleanUpTaskListenersBehavior: [ 'type', CleanUpTaskListenersBehavior ],
-    cleanUpSubscriptionBehavior: [ 'type', CleanUpSubscriptionBehavior ],
-    cleanUpTimerExpressionBehavior: [ 'type', CleanUpTimerExpressionBehavior ],
-    copyPasteBehavior: [ 'type', ZeebeModdleExtension ],
-    createZeebeCallActivityBehavior: [ 'type', CreateZeebeCallActivityBehavior ],
-    deleteParticipantBehaviour: [ 'type', DeleteParticipantBehaviour ],
-    formsBehavior: [ 'type', FormsBehavior ],
-    removeAssignmentDefinitionBehavior: [ 'type', RemoveAssignmentDefinitionBehavior ],
-    removeTaskScheduleBehavior: [ 'type', RemoveTaskScheduleBehavior ],
-    versionTagBehavior: [ 'type', VersionTagBehavior ]
+  var behaviorsModule = {
+    __init__: [
+      'cleanUpBusinessRuleTaskBehavior',
+      'cleanUpEndEventBehavior',
+      'cleanUpExecutionListenersBehavior',
+      'cleanUpTaskListenersBehavior',
+      'cleanUpSubscriptionBehavior',
+      'cleanUpTimerExpressionBehavior',
+      'copyPasteBehavior',
+      'createZeebeCallActivityBehavior',
+      'deleteParticipantBehaviour',
+      'formsBehavior',
+      'removeAssignmentDefinitionBehavior',
+      'removeTaskScheduleBehavior',
+      'versionTagBehavior'
+    ],
+    cleanUpBusinessRuleTaskBehavior: [ 'type', CleanUpBusinessRuleTaskBehavior ],
+    cleanUpEndEventBehavior: [ 'type', CleanUpEndEventBehavior ],
+    cleanUpExecutionListenersBehavior: [ 'type', CleanUpExecutionListenersBehavior ],
+    cleanUpTaskListenersBehavior: [ 'type', CleanUpTaskListenersBehavior ],
+    cleanUpSubscriptionBehavior: [ 'type', CleanUpSubscriptionBehavior ],
+    cleanUpTimerExpressionBehavior: [ 'type', CleanUpTimerExpressionBehavior ],
+    copyPasteBehavior: [ 'type', ZeebeModdleExtension ],
+    createZeebeCallActivityBehavior: [ 'type', CreateZeebeCallActivityBehavior ],
+    deleteParticipantBehaviour: [ 'type', DeleteParticipantBehaviour ],
+    formsBehavior: [ 'type', FormsBehavior ],
+    removeAssignmentDefinitionBehavior: [ 'type', RemoveAssignmentDefinitionBehavior ],
+    removeTaskScheduleBehavior: [ 'type', RemoveTaskScheduleBehavior ],
+    versionTagBehavior: [ 'type', VersionTagBehavior ]
   };
 
   /**