camunda-bpmn-js 5.16.0 → 5.17.0

package/dist/base-navigated-viewer.development.js

@@ -16,31 +16,27 @@
    * @return {T[]}
    */
 
-  const nativeToString$2 = Object.prototype.toString;
-  const nativeHasOwnProperty$2 = Object.prototype.hasOwnProperty;
+  const nativeToString$6 = Object.prototype.toString;
+  const nativeHasOwnProperty$5 = Object.prototype.hasOwnProperty;
 
-  function isUndefined$3(obj) {
+  function isUndefined$6(obj) {
     return obj === undefined;
   }
 
-  function isDefined(obj) {
-    return obj !== undefined;
-  }
-
-  function isNil(obj) {
+  function isNil$3(obj) {
     return obj == null;
   }
 
-  function isArray$3(obj) {
-    return nativeToString$2.call(obj) === '[object Array]';
+  function isArray$6(obj) {
+    return nativeToString$6.call(obj) === '[object Array]';
   }
 
-  function isObject(obj) {
-    return nativeToString$2.call(obj) === '[object Object]';
+  function isObject$2(obj) {
+    return nativeToString$6.call(obj) === '[object Object]';
   }
 
-  function isNumber(obj) {
-    return nativeToString$2.call(obj) === '[object Number]';
+  function isNumber$1(obj) {
+    return nativeToString$6.call(obj) === '[object Number]';
   }
 
   /**
@@ -48,8 +44,8 @@
    *
    * @return {boolean}
    */
-  function isFunction(obj) {
-    const tag = nativeToString$2.call(obj);
+  function isFunction$2(obj) {
+    const tag = nativeToString$6.call(obj);
 
     return (
       tag === '[object Function]' ||
@@ -60,10 +56,6 @@
     );
   }
 
-  function isString(obj) {
-    return nativeToString$2.call(obj) === '[object String]';
-  }
-
   /**
    * Return true, if target owns a property with the given key.
    *
@@ -72,8 +64,8 @@
    *
    * @return {Boolean}
    */
-  function has$2(target, key) {
-    return !isNil(target) && nativeHasOwnProperty$2.call(target, key);
+  function has$5(target, key) {
+    return !isNil$3(target) && nativeHasOwnProperty$5.call(target, key);
   }
 
   /**
@@ -136,13 +128,13 @@
    *
    * @return {Object}
    */
-  function find(collection, matcher) {
+  function find$2(collection, matcher) {
 
-    const matchFn = toMatcher(matcher);
+    const matchFn = toMatcher$2(matcher);
 
     let match;
 
-    forEach$2(collection, function(val, key) {
+    forEach$5(collection, function(val, key) {
       if (matchFn(val, key)) {
         match = val;
 
@@ -155,33 +147,6 @@
   }
 
 
-  /**
-   * Find element index in collection.
-   *
-   * @template T
-   * @param {Collection<T>} collection
-   * @param {Matcher<T>} matcher
-   *
-   * @return {number | string | undefined}
-   */
-  function findIndex(collection, matcher) {
-
-    const matchFn = toMatcher(matcher);
-
-    let idx = isArray$3(collection) ? -1 : undefined;
-
-    forEach$2(collection, function(val, key) {
-      if (matchFn(val, key)) {
-        idx = key;
-
-        return false;
-      }
-    });
-
-    return idx;
-  }
-
-
   /**
    * Filter elements in collection.
    *
@@ -191,13 +156,13 @@
    *
    * @return {T[]} result
    */
-  function filter(collection, matcher) {
+  function filter$2(collection, matcher) {
 
-    const matchFn = toMatcher(matcher);
+    const matchFn = toMatcher$2(matcher);
 
     let result = [];
 
-    forEach$2(collection, function(val, key) {
+    forEach$5(collection, function(val, key) {
       if (matchFn(val, key)) {
         result.push(val);
       }
@@ -217,20 +182,20 @@
    *
    * @return {T} return result that stopped the iteration
    */
-  function forEach$2(collection, iterator) {
+  function forEach$5(collection, iterator) {
 
     let val,
         result;
 
-    if (isUndefined$3(collection)) {
+    if (isUndefined$6(collection)) {
       return;
     }
 
-    const convertKey = isArray$3(collection) ? toNum$2 : identity$2;
+    const convertKey = isArray$6(collection) ? toNum$5 : identity$5;
 
     for (let key in collection) {
 
-      if (has$2(collection, key)) {
+      if (has$5(collection, key)) {
         val = collection[key];
 
         result = iterator(val, convertKey(key));
@@ -243,45 +208,6 @@
   }
 
 
-  /**
-   * Reduce collection, returning a single result.
-   *
-   * @template T
-   * @template V
-   *
-   * @param {Collection<T>} collection
-   * @param {(result: V, entry: T, index: any) => V} iterator
-   * @param {V} result
-   *
-   * @return {V} result returned from last iterator
-   */
-  function reduce(collection, iterator, result) {
-
-    forEach$2(collection, function(value, idx) {
-      result = iterator(result, value, idx);
-    });
-
-    return result;
-  }
-
-
-  /**
-   * Return true if every element in the collection
-   * matches the criteria.
-   *
-   * @param  {Object|Array} collection
-   * @param  {Function} matcher
-   *
-   * @return {Boolean}
-   */
-  function every(collection, matcher) {
-
-    return !!reduce(collection, function(matches, val, key) {
-      return matches && matcher(val, key);
-    }, true);
-  }
-
-
   /**
    * Return true if some elements in the collection
    * match the criteria.
@@ -293,7 +219,7 @@
    */
   function some(collection, matcher) {
 
-    return !!find(collection, matcher);
+    return !!find$2(collection, matcher);
   }
 
 
@@ -310,7 +236,7 @@
 
     let result = [];
 
-    forEach$2(collection, function(val, key) {
+    forEach$5(collection, function(val, key) {
       result.push(fn(val, key));
     });
 
@@ -318,331 +244,124 @@
   }
 
 
-  /**
-   * Create an object pattern matcher.
-   *
-   * @example
-   *
-   * ```javascript
-   * const matcher = matchPattern({ id: 1 });
-   *
-   * let element = find(elements, matcher);
-   * ```
-   *
-   * @template T
-   *
-   * @param {T} pattern
-   *
-   * @return { (el: any) =>  boolean } matcherFn
-   */
-  function matchPattern(pattern) {
-
-    return function(el) {
-
-      return every(pattern, function(val, key) {
-        return el[key] === val;
-      });
-
-    };
-  }
-
-
   /**
    * @template T
    * @param {Matcher<T>} matcher
    *
    * @return {MatchFn<T>}
    */
-  function toMatcher(matcher) {
-    return isFunction(matcher) ? matcher : (e) => {
+  function toMatcher$2(matcher) {
+    return isFunction$2(matcher) ? matcher : (e) => {
       return e === matcher;
     };
   }
 
 
-  function identity$2(arg) {
+  function identity$5(arg) {
     return arg;
   }
 
-  function toNum$2(arg) {
+  function toNum$5(arg) {
     return Number(arg);
   }
 
-  /* global setTimeout clearTimeout */
-
   /**
-   * @typedef { {
-   *   (...args: any[]): any;
-   *   flush: () => void;
-   *   cancel: () => void;
-   * } } DebouncedFunction
+   * Convenience wrapper for `Object.assign`.
+   *
+   * @param {Object} target
+   * @param {...Object} others
+   *
+   * @return {Object} the target
    */
+  function assign$6(target, ...others) {
+    return Object.assign(target, ...others);
+  }
 
   /**
-   * Debounce fn, calling it only once if the given time
-   * elapsed between calls.
+   * Pick all target properties, excluding the given ones.
    *
-   * Lodash-style the function exposes methods to `#clear`
-   * and `#flush` to control internal behavior.
+   * @template T
+   * @template {any[]} V
    *
-   * @param  {Function} fn
-   * @param  {Number} timeout
+   * @param {T} target
+   * @param {V} properties
    *
-   * @return {DebouncedFunction} debounced function
+   * @return {Omit<T, V>} target
    */
-  function debounce(fn, timeout) {
-
-    let timer;
-
-    let lastArgs;
-    let lastThis;
-
-    let lastNow;
+  function omit(target, properties) {
 
-    function fire(force) {
+    let result = {};
 
-      let now = Date.now();
+    let obj = Object(target);
 
-      let scheduledDiff = force ? 0 : (lastNow + timeout) - now;
+    forEach$5(obj, function(prop, key) {
 
-      if (scheduledDiff > 0) {
-        return schedule(scheduledDiff);
+      if (properties.indexOf(key) === -1) {
+        result[key] = prop;
       }
+    });
 
-      fn.apply(lastThis, lastArgs);
-
-      clear();
-    }
-
-    function schedule(timeout) {
-      timer = setTimeout(fire, timeout);
-    }
-
-    function clear() {
-      if (timer) {
-        clearTimeout(timer);
-      }
+    return result;
+  }
 
-      timer = lastNow = lastArgs = lastThis = undefined;
-    }
+  var DEFAULT_RENDER_PRIORITY$1 = 1000;
 
-    function flush() {
-      if (timer) {
-        fire(true);
-      }
+  /**
+   * @typedef {import('../core/Types').ElementLike} Element
+   * @typedef {import('../core/Types').ConnectionLike} Connection
+   * @typedef {import('../core/Types').ShapeLike} Shape
+   *
+   * @typedef {import('../core/EventBus').default} EventBus
+   */
 
-      clear();
-    }
+  /**
+   * The base implementation of shape and connection renderers.
+   *
+   * @param {EventBus} eventBus
+   * @param {number} [renderPriority=1000]
+   */
+  function BaseRenderer(eventBus, renderPriority) {
+    var self = this;
 
-    /**
-     * @type { DebouncedFunction }
-     */
-    function callback(...args) {
-      lastNow = Date.now();
+    renderPriority = renderPriority || DEFAULT_RENDER_PRIORITY$1;
 
-      lastArgs = args;
-      lastThis = this;
+    eventBus.on([ 'render.shape', 'render.connection' ], renderPriority, function(evt, context) {
+      var type = evt.type,
+          element = context.element,
+          visuals = context.gfx,
+          attrs = context.attrs;
 
-      // ensure an execution is scheduled
-      if (!timer) {
-        schedule(timeout);
+      if (self.canRender(element)) {
+        if (type === 'render.shape') {
+          return self.drawShape(visuals, element, attrs);
+        } else {
+          return self.drawConnection(visuals, element, attrs);
+        }
       }
-    }
-
-    callback.flush = flush;
-    callback.cancel = clear;
+    });
 
-    return callback;
+    eventBus.on([ 'render.getShapePath', 'render.getConnectionPath' ], renderPriority, function(evt, element) {
+      if (self.canRender(element)) {
+        if (evt.type === 'render.getShapePath') {
+          return self.getShapePath(element);
+        } else {
+          return self.getConnectionPath(element);
+        }
+      }
+    });
   }
 
   /**
-   * Bind function against target <this>.
+   * Checks whether an element can be rendered.
    *
-   * @param  {Function} fn
-   * @param  {Object}   target
+   * @param {Element} element The element to be rendered.
    *
-   * @return {Function} bound function
+   * @return {boolean} Whether the element can be rendered.
    */
-  function bind$3(fn, target) {
-    return fn.bind(target);
-  }
+  BaseRenderer.prototype.canRender = function(element) {};
 
   /**
-   * Convenience wrapper for `Object.assign`.
-   *
-   * @param {Object} target
-   * @param {...Object} others
-   *
-   * @return {Object} the target
-   */
-  function assign$2(target, ...others) {
-    return Object.assign(target, ...others);
-  }
-
-  /**
-   * Sets a nested property of a given object to the specified value.
-   *
-   * This mutates the object and returns it.
-   *
-   * @template T
-   *
-   * @param {T} target The target of the set operation.
-   * @param {(string|number)[]} path The path to the nested value.
-   * @param {any} value The value to set.
-   *
-   * @return {T}
-   */
-  function set$1(target, path, value) {
-
-    let currentTarget = target;
-
-    forEach$2(path, function(key, idx) {
-
-      if (typeof key !== 'number' && typeof key !== 'string') {
-        throw new Error('illegal key type: ' + typeof key + '. Key should be of type number or string.');
-      }
-
-      if (key === 'constructor') {
-        throw new Error('illegal key: constructor');
-      }
-
-      if (key === '__proto__') {
-        throw new Error('illegal key: __proto__');
-      }
-
-      let nextKey = path[idx + 1];
-      let nextTarget = currentTarget[key];
-
-      if (isDefined(nextKey) && isNil(nextTarget)) {
-        nextTarget = currentTarget[key] = isNaN(+nextKey) ? {} : [];
-      }
-
-      if (isUndefined$3(nextKey)) {
-        if (isUndefined$3(value)) {
-          delete currentTarget[key];
-        } else {
-          currentTarget[key] = value;
-        }
-      } else {
-        currentTarget = nextTarget;
-      }
-    });
-
-    return target;
-  }
-
-  /**
-   * Pick properties from the given target.
-   *
-   * @template T
-   * @template {any[]} V
-   *
-   * @param {T} target
-   * @param {V} properties
-   *
-   * @return Pick<T, V>
-   */
-  function pick(target, properties) {
-
-    let result = {};
-
-    let obj = Object(target);
-
-    forEach$2(properties, function(prop) {
-
-      if (prop in obj) {
-        result[prop] = target[prop];
-      }
-    });
-
-    return result;
-  }
-
-  /**
-   * Pick all target properties, excluding the given ones.
-   *
-   * @template T
-   * @template {any[]} V
-   *
-   * @param {T} target
-   * @param {V} properties
-   *
-   * @return {Omit<T, V>} target
-   */
-  function omit(target, properties) {
-
-    let result = {};
-
-    let obj = Object(target);
-
-    forEach$2(obj, function(prop, key) {
-
-      if (properties.indexOf(key) === -1) {
-        result[key] = prop;
-      }
-    });
-
-    return result;
-  }
-
-  var DEFAULT_RENDER_PRIORITY$1 = 1000;
-
-  /**
-   * @typedef {import('../core/Types').ElementLike} Element
-   * @typedef {import('../core/Types').ConnectionLike} Connection
-   * @typedef {import('../core/Types').ShapeLike} Shape
-   *
-   * @typedef {import('../core/EventBus').default} EventBus
-   */
-
-  /**
-   * The base implementation of shape and connection renderers.
-   *
-   * @param {EventBus} eventBus
-   * @param {number} [renderPriority=1000]
-   */
-  function BaseRenderer(eventBus, renderPriority) {
-    var self = this;
-
-    renderPriority = renderPriority || DEFAULT_RENDER_PRIORITY$1;
-
-    eventBus.on([ 'render.shape', 'render.connection' ], renderPriority, function(evt, context) {
-      var type = evt.type,
-          element = context.element,
-          visuals = context.gfx,
-          attrs = context.attrs;
-
-      if (self.canRender(element)) {
-        if (type === 'render.shape') {
-          return self.drawShape(visuals, element, attrs);
-        } else {
-          return self.drawConnection(visuals, element, attrs);
-        }
-      }
-    });
-
-    eventBus.on([ 'render.getShapePath', 'render.getConnectionPath' ], renderPriority, function(evt, element) {
-      if (self.canRender(element)) {
-        if (evt.type === 'render.getShapePath') {
-          return self.getShapePath(element);
-        } else {
-          return self.getConnectionPath(element);
-        }
-      }
-    });
-  }
-
-  /**
-   * Checks whether an element can be rendered.
-   *
-   * @param {Element} element The element to be rendered.
-   *
-   * @return {boolean} Whether the element can be rendered.
-   */
-  BaseRenderer.prototype.canRender = function(element) {};
-
-  /**
-   * Draws a shape.
+   * Draws a shape.
    *
    * @param {SVGElement} visuals The SVG element to draw the shape into.
    * @param {Shape} shape The shape to be drawn.
@@ -799,301 +518,711 @@
   }
 
   /**
-   * Checks whether a value is an instance of Connection.
+   * Flatten array, one level deep.
    *
-   * @param {any} value
+   * @template T
    *
-   * @return {boolean}
+   * @param {T[][] | T[] | null} [arr]
+   *
+   * @return {T[]}
    */
-  function isConnection(value) {
-    return isObject(value) && has$2(value, 'waypoints');
+
+  const nativeToString$5 = Object.prototype.toString;
+  const nativeHasOwnProperty$4 = Object.prototype.hasOwnProperty;
+
+  function isUndefined$5(obj) {
+    return obj === undefined;
   }
 
-  /**
-   * Checks whether a value is an instance of Label.
-   *
-   * @param {any} value
-   *
-   * @return {boolean}
-   */
-  function isLabel(value) {
-    return isObject(value) && has$2(value, 'labelTarget');
+  function isDefined$1(obj) {
+    return obj !== undefined;
   }
 
-  /**
-   * @typedef {import('diagram-js/lib/util/Types').Point} Point
-   * @typedef {import('diagram-js/lib/util/Types').Rect} Rect
-   *
-   * @typedef {import('../model/Types').Element} Element
-   * @typedef {import('../model/Types').ModdleElement} ModdleElement
-   */
+  function isNil$2(obj) {
+    return obj == null;
+  }
 
-  var DEFAULT_LABEL_SIZE$1 = {
-    width: 90,
-    height: 20
-  };
+  function isArray$5(obj) {
+    return nativeToString$5.call(obj) === '[object Array]';
+  }
 
-  var FLOW_LABEL_INDENT = 15;
+  function isObject$1(obj) {
+    return nativeToString$5.call(obj) === '[object Object]';
+  }
 
+  function isNumber(obj) {
+    return nativeToString$5.call(obj) === '[object Number]';
+  }
 
   /**
-   * Return true if the given semantic has an external label.
-   *
-   * @param {Element} semantic
+   * @param {any} obj
    *
    * @return {boolean}
    */
-  function isLabelExternal(semantic) {
-    return is$1(semantic, 'bpmn:Event') ||
-           is$1(semantic, 'bpmn:Gateway') ||
-           is$1(semantic, 'bpmn:DataStoreReference') ||
-           is$1(semantic, 'bpmn:DataObjectReference') ||
-           is$1(semantic, 'bpmn:DataInput') ||
-           is$1(semantic, 'bpmn:DataOutput') ||
-           is$1(semantic, 'bpmn:SequenceFlow') ||
-           is$1(semantic, 'bpmn:MessageFlow') ||
-           is$1(semantic, 'bpmn:Group');
+  function isFunction$1(obj) {
+    const tag = nativeToString$5.call(obj);
+
+    return (
+      tag === '[object Function]' ||
+      tag === '[object AsyncFunction]' ||
+      tag === '[object GeneratorFunction]' ||
+      tag === '[object AsyncGeneratorFunction]' ||
+      tag === '[object Proxy]'
+    );
+  }
+
+  function isString$3(obj) {
+    return nativeToString$5.call(obj) === '[object String]';
   }
 
   /**
-   * Get the position of a sequence flow label.
+   * Return true, if target owns a property with the given key.
    *
-   * @param  {Point[]} waypoints
+   * @param {Object} target
+   * @param {String} key
    *
-   * @return {Point}
+   * @return {Boolean}
    */
-  function getFlowLabelPosition(waypoints) {
-
-    // get the waypoints mid
-    var mid = waypoints.length / 2 - 1;
-
-    var first = waypoints[Math.floor(mid)];
-    var second = waypoints[Math.ceil(mid + 0.01)];
-
-    // get position
-    var position = getWaypointsMid(waypoints);
-
-    // calculate angle
-    var angle = Math.atan((second.y - first.y) / (second.x - first.x));
-
-    var x = position.x,
-        y = position.y;
-
-    if (Math.abs(angle) < Math.PI / 2) {
-      y -= FLOW_LABEL_INDENT;
-    } else {
-      x += FLOW_LABEL_INDENT;
-    }
-
-    return { x: x, y: y };
-  }
+  function has$4(target, key) {
+    return !isNil$2(target) && nativeHasOwnProperty$4.call(target, key);
+  }
 
+  /**
+   * @template T
+   * @typedef { (
+   *   ((e: T) => boolean) |
+   *   ((e: T, idx: number) => boolean) |
+   *   ((e: T, key: string) => boolean) |
+   *   string |
+   *   number
+   * ) } Matcher
+   */
 
   /**
-   * Get the middle of a number of waypoints.
-   *
-   * @param  {Point[]} waypoints
+   * @template T
+   * @template U
    *
-   * @return {Point}
+   * @typedef { (
+   *   ((e: T) => U) | string | number
+   * ) } Extractor
    */
-  function getWaypointsMid(waypoints) {
 
-    var mid = waypoints.length / 2 - 1;
 
-    var first = waypoints[Math.floor(mid)];
-    var second = waypoints[Math.ceil(mid + 0.01)];
+  /**
+   * @template T
+   * @typedef { (val: T, key: any) => boolean } MatchFn
+   */
 
-    return {
-      x: first.x + (second.x - first.x) / 2,
-      y: first.y + (second.y - first.y) / 2
-    };
-  }
+  /**
+   * @template T
+   * @typedef { T[] } ArrayCollection
+   */
 
   /**
-   * Get the middle of the external label of an element.
-   *
-   * @param {Element} element
-   *
-   * @return {Point}
+   * @template T
+   * @typedef { { [key: string]: T } } StringKeyValueCollection
    */
-  function getExternalLabelMid(element) {
 
-    if (element.waypoints) {
-      return getFlowLabelPosition(element.waypoints);
-    } else if (is$1(element, 'bpmn:Group')) {
-      return {
-        x: element.x + element.width / 2,
-        y: element.y + DEFAULT_LABEL_SIZE$1.height / 2
-      };
-    } else {
-      return {
-        x: element.x + element.width / 2,
-        y: element.y + element.height + DEFAULT_LABEL_SIZE$1.height / 2
-      };
-    }
-  }
+  /**
+   * @template T
+   * @typedef { { [key: number]: T } } NumberKeyValueCollection
+   */
 
+  /**
+   * @template T
+   * @typedef { StringKeyValueCollection<T> | NumberKeyValueCollection<T> } KeyValueCollection
+   */
 
   /**
-   * Return the bounds of an elements label, parsed from the elements DI or
-   * generated from its bounds.
+   * @template T
+   * @typedef { KeyValueCollection<T> | ArrayCollection<T> } Collection
+   */
+
+  /**
+   * Find element in collection.
    *
-   * @param {ModdleElement} di
-   * @param {Element} element
+   * @template T
+   * @param {Collection<T>} collection
+   * @param {Matcher<T>} matcher
    *
-   * @return {Rect}
+   * @return {Object}
    */
-  function getExternalLabelBounds(di, element) {
-
-    var mid,
-        size,
-        bounds,
-        label = di.label;
+  function find$1(collection, matcher) {
 
-    if (label && label.bounds) {
-      bounds = label.bounds;
+    const matchFn = toMatcher$1(matcher);
 
-      size = {
-        width: Math.max(DEFAULT_LABEL_SIZE$1.width, bounds.width),
-        height: bounds.height
-      };
+    let match;
 
-      mid = {
-        x: bounds.x + bounds.width / 2,
-        y: bounds.y + bounds.height / 2
-      };
-    } else {
+    forEach$4(collection, function(val, key) {
+      if (matchFn(val, key)) {
+        match = val;
 
-      mid = getExternalLabelMid(element);
+        return false;
+      }
+    });
 
-      size = DEFAULT_LABEL_SIZE$1;
-    }
+    return match;
 
-    return assign$2({
-      x: mid.x - size.width / 2,
-      y: mid.y - size.height / 2
-    }, size);
   }
 
-  /**
-   * @param {ModdleElement} semantic
-   *
-   * @returns {string}
-   */
-  function getLabelAttr(semantic) {
-    if (
-      is$1(semantic, 'bpmn:FlowElement') ||
-      is$1(semantic, 'bpmn:Participant') ||
-      is$1(semantic, 'bpmn:Lane') ||
-      is$1(semantic, 'bpmn:SequenceFlow') ||
-      is$1(semantic, 'bpmn:MessageFlow') ||
-      is$1(semantic, 'bpmn:DataInput') ||
-      is$1(semantic, 'bpmn:DataOutput')
-    ) {
-      return 'name';
-    }
-
-    if (is$1(semantic, 'bpmn:TextAnnotation')) {
-      return 'text';
-    }
-
-    if (is$1(semantic, 'bpmn:Group')) {
-      return 'categoryValueRef';
-    }
-  }
 
   /**
-   * @param {ModdleElement} semantic
+   * Filter elements in collection.
    *
-   * @returns {string}
+   * @template T
+   * @param {Collection<T>} collection
+   * @param {Matcher<T>} matcher
+   *
+   * @return {T[]} result
    */
-  function getCategoryValue(semantic) {
-    var categoryValueRef = semantic['categoryValueRef'];
+  function filter$1(collection, matcher) {
 
-    if (!categoryValueRef) {
-      return '';
-    }
+    const matchFn = toMatcher$1(matcher);
 
+    let result = [];
 
-    return categoryValueRef.value || '';
+    forEach$4(collection, function(val, key) {
+      if (matchFn(val, key)) {
+        result.push(val);
+      }
+    });
+
+    return result;
   }
 
+
   /**
-   * @param {Element} element
+   * Iterate over collection; returning something
+   * (non-undefined) will stop iteration.
    *
-   * @return {string}
+   * @template T
+   * @param {Collection<T>} collection
+   * @param { ((item: T, idx: number) => (boolean|void)) | ((item: T, key: string) => (boolean|void)) } iterator
+   *
+   * @return {T} return result that stopped the iteration
    */
-  function getLabel(element) {
-    var semantic = element.businessObject,
-        attr = getLabelAttr(semantic);
-
-    if (attr) {
-
-      if (attr === 'categoryValueRef') {
+  function forEach$4(collection, iterator) {
 
-        return getCategoryValue(semantic);
-      }
+    let val,
+        result;
 
-      return semantic[attr] || '';
+    if (isUndefined$5(collection)) {
+      return;
     }
-  }
 
-  function ensureImported(element, target) {
+    const convertKey = isArray$5(collection) ? toNum$4 : identity$4;
 
-    if (element.ownerDocument !== target.ownerDocument) {
-      try {
+    for (let key in collection) {
 
-        // may fail on webkit
-        return target.ownerDocument.importNode(element, true);
-      } catch (e) {
+      if (has$4(collection, key)) {
+        val = collection[key];
 
-        // ignore
+        result = iterator(val, convertKey(key));
+
+        if (result === false) {
+          return val;
+        }
       }
     }
-
-    return element;
   }
 
-  /**
-   * appendTo utility
-   */
-
 
   /**
-   * Append a node to a target element and return the appended node.
+   * Reduce collection, returning a single result.
    *
-   * @param  {SVGElement} element
-   * @param  {SVGElement} target
+   * @template T
+   * @template V
    *
-   * @return {SVGElement} the appended node
+   * @param {Collection<T>} collection
+   * @param {(result: V, entry: T, index: any) => V} iterator
+   * @param {V} result
+   *
+   * @return {V} result returned from last iterator
    */
-  function appendTo(element, target) {
-    return target.appendChild(ensureImported(element, target));
-  }
+  function reduce(collection, iterator, result) {
 
-  /**
-   * append utility
-   */
+    forEach$4(collection, function(value, idx) {
+      result = iterator(result, value, idx);
+    });
+
+    return result;
+  }
 
 
   /**
-   * Append a node to an element
+   * Return true if every element in the collection
+   * matches the criteria.
    *
-   * @param  {SVGElement} element
-   * @param  {SVGElement} node
+   * @param  {Object|Array} collection
+   * @param  {Function} matcher
    *
-   * @return {SVGElement} the element
+   * @return {Boolean}
    */
-  function append(target, node) {
-    appendTo(node, target);
-    return target;
-  }
+  function every(collection, matcher) {
 
-  /**
-   * attribute accessor utility
-   */
+    return !!reduce(collection, function(matches, val, key) {
+      return matches && matcher(val, key);
+    }, true);
+  }
 
-  var LENGTH_ATTR = 2;
+
+  /**
+   * Create an object pattern matcher.
+   *
+   * @example
+   *
+   * ```javascript
+   * const matcher = matchPattern({ id: 1 });
+   *
+   * let element = find(elements, matcher);
+   * ```
+   *
+   * @template T
+   *
+   * @param {T} pattern
+   *
+   * @return { (el: any) =>  boolean } matcherFn
+   */
+  function matchPattern(pattern) {
+
+    return function(el) {
+
+      return every(pattern, function(val, key) {
+        return el[key] === val;
+      });
+
+    };
+  }
+
+
+  /**
+   * @template T
+   * @param {Matcher<T>} matcher
+   *
+   * @return {MatchFn<T>}
+   */
+  function toMatcher$1(matcher) {
+    return isFunction$1(matcher) ? matcher : (e) => {
+      return e === matcher;
+    };
+  }
+
+
+  function identity$4(arg) {
+    return arg;
+  }
+
+  function toNum$4(arg) {
+    return Number(arg);
+  }
+
+  /* global setTimeout clearTimeout */
+
+  /**
+   * @typedef { {
+   *   (...args: any[]): any;
+   *   flush: () => void;
+   *   cancel: () => void;
+   * } } DebouncedFunction
+   */
+
+  /**
+   * Debounce fn, calling it only once if the given time
+   * elapsed between calls.
+   *
+   * Lodash-style the function exposes methods to `#clear`
+   * and `#flush` to control internal behavior.
+   *
+   * @param  {Function} fn
+   * @param  {Number} timeout
+   *
+   * @return {DebouncedFunction} debounced function
+   */
+  function debounce(fn, timeout) {
+
+    let timer;
+
+    let lastArgs;
+    let lastThis;
+
+    let lastNow;
+
+    function fire(force) {
+
+      let now = Date.now();
+
+      let scheduledDiff = force ? 0 : (lastNow + timeout) - now;
+
+      if (scheduledDiff > 0) {
+        return schedule(scheduledDiff);
+      }
+
+      fn.apply(lastThis, lastArgs);
+
+      clear();
+    }
+
+    function schedule(timeout) {
+      timer = setTimeout(fire, timeout);
+    }
+
+    function clear() {
+      if (timer) {
+        clearTimeout(timer);
+      }
+
+      timer = lastNow = lastArgs = lastThis = undefined;
+    }
+
+    function flush() {
+      if (timer) {
+        fire(true);
+      }
+
+      clear();
+    }
+
+    /**
+     * @type { DebouncedFunction }
+     */
+    function callback(...args) {
+      lastNow = Date.now();
+
+      lastArgs = args;
+      lastThis = this;
+
+      // ensure an execution is scheduled
+      if (!timer) {
+        schedule(timeout);
+      }
+    }
+
+    callback.flush = flush;
+    callback.cancel = clear;
+
+    return callback;
+  }
+
+  /**
+   * Bind function against target <this>.
+   *
+   * @param  {Function} fn
+   * @param  {Object}   target
+   *
+   * @return {Function} bound function
+   */
+  function bind$4(fn, target) {
+    return fn.bind(target);
+  }
+
+  /**
+   * Convenience wrapper for `Object.assign`.
+   *
+   * @param {Object} target
+   * @param {...Object} others
+   *
+   * @return {Object} the target
+   */
+  function assign$5(target, ...others) {
+    return Object.assign(target, ...others);
+  }
+
+  /**
+   * Checks whether a value is an instance of Connection.
+   *
+   * @param {any} value
+   *
+   * @return {boolean}
+   */
+  function isConnection(value) {
+    return isObject$1(value) && has$4(value, 'waypoints');
+  }
+
+  /**
+   * Checks whether a value is an instance of Label.
+   *
+   * @param {any} value
+   *
+   * @return {boolean}
+   */
+  function isLabel(value) {
+    return isObject$1(value) && has$4(value, 'labelTarget');
+  }
+
+  /**
+   * @typedef {import('diagram-js/lib/util/Types').Point} Point
+   * @typedef {import('diagram-js/lib/util/Types').Rect} Rect
+   *
+   * @typedef {import('../model/Types').Element} Element
+   * @typedef {import('../model/Types').ModdleElement} ModdleElement
+   */
+
+  var DEFAULT_LABEL_SIZE$1 = {
+    width: 90,
+    height: 20
+  };
+
+  var FLOW_LABEL_INDENT = 15;
+
+
+  /**
+   * Return true if the given semantic has an external label.
+   *
+   * @param {Element} semantic
+   *
+   * @return {boolean}
+   */
+  function isLabelExternal(semantic) {
+    return is$1(semantic, 'bpmn:Event') ||
+           is$1(semantic, 'bpmn:Gateway') ||
+           is$1(semantic, 'bpmn:DataStoreReference') ||
+           is$1(semantic, 'bpmn:DataObjectReference') ||
+           is$1(semantic, 'bpmn:DataInput') ||
+           is$1(semantic, 'bpmn:DataOutput') ||
+           is$1(semantic, 'bpmn:SequenceFlow') ||
+           is$1(semantic, 'bpmn:MessageFlow') ||
+           is$1(semantic, 'bpmn:Group');
+  }
+
+  /**
+   * Get the position of a sequence flow label.
+   *
+   * @param  {Point[]} waypoints
+   *
+   * @return {Point}
+   */
+  function getFlowLabelPosition(waypoints) {
+
+    // get the waypoints mid
+    var mid = waypoints.length / 2 - 1;
+
+    var first = waypoints[Math.floor(mid)];
+    var second = waypoints[Math.ceil(mid + 0.01)];
+
+    // get position
+    var position = getWaypointsMid(waypoints);
+
+    // calculate angle
+    var angle = Math.atan((second.y - first.y) / (second.x - first.x));
+
+    var x = position.x,
+        y = position.y;
+
+    if (Math.abs(angle) < Math.PI / 2) {
+      y -= FLOW_LABEL_INDENT;
+    } else {
+      x += FLOW_LABEL_INDENT;
+    }
+
+    return { x: x, y: y };
+  }
+
+
+  /**
+   * Get the middle of a number of waypoints.
+   *
+   * @param  {Point[]} waypoints
+   *
+   * @return {Point}
+   */
+  function getWaypointsMid(waypoints) {
+
+    var mid = waypoints.length / 2 - 1;
+
+    var first = waypoints[Math.floor(mid)];
+    var second = waypoints[Math.ceil(mid + 0.01)];
+
+    return {
+      x: first.x + (second.x - first.x) / 2,
+      y: first.y + (second.y - first.y) / 2
+    };
+  }
+
+  /**
+   * Get the middle of the external label of an element.
+   *
+   * @param {Element} element
+   *
+   * @return {Point}
+   */
+  function getExternalLabelMid(element) {
+
+    if (element.waypoints) {
+      return getFlowLabelPosition(element.waypoints);
+    } else if (is$1(element, 'bpmn:Group')) {
+      return {
+        x: element.x + element.width / 2,
+        y: element.y + DEFAULT_LABEL_SIZE$1.height / 2
+      };
+    } else {
+      return {
+        x: element.x + element.width / 2,
+        y: element.y + element.height + DEFAULT_LABEL_SIZE$1.height / 2
+      };
+    }
+  }
+
+
+  /**
+   * Return the bounds of an elements label, parsed from the elements DI or
+   * generated from its bounds.
+   *
+   * @param {ModdleElement} di
+   * @param {Element} element
+   *
+   * @return {Rect}
+   */
+  function getExternalLabelBounds(di, element) {
+
+    var mid,
+        size,
+        bounds,
+        label = di.label;
+
+    if (label && label.bounds) {
+      bounds = label.bounds;
+
+      size = {
+        width: Math.max(DEFAULT_LABEL_SIZE$1.width, bounds.width),
+        height: bounds.height
+      };
+
+      mid = {
+        x: bounds.x + bounds.width / 2,
+        y: bounds.y + bounds.height / 2
+      };
+    } else {
+
+      mid = getExternalLabelMid(element);
+
+      size = DEFAULT_LABEL_SIZE$1;
+    }
+
+    return assign$6({
+      x: mid.x - size.width / 2,
+      y: mid.y - size.height / 2
+    }, size);
+  }
+
+  /**
+   * @param {ModdleElement} semantic
+   *
+   * @returns {string}
+   */
+  function getLabelAttr(semantic) {
+    if (
+      is$1(semantic, 'bpmn:FlowElement') ||
+      is$1(semantic, 'bpmn:Participant') ||
+      is$1(semantic, 'bpmn:Lane') ||
+      is$1(semantic, 'bpmn:SequenceFlow') ||
+      is$1(semantic, 'bpmn:MessageFlow') ||
+      is$1(semantic, 'bpmn:DataInput') ||
+      is$1(semantic, 'bpmn:DataOutput')
+    ) {
+      return 'name';
+    }
+
+    if (is$1(semantic, 'bpmn:TextAnnotation')) {
+      return 'text';
+    }
+
+    if (is$1(semantic, 'bpmn:Group')) {
+      return 'categoryValueRef';
+    }
+  }
+
+  /**
+   * @param {ModdleElement} semantic
+   *
+   * @returns {string}
+   */
+  function getCategoryValue(semantic) {
+    var categoryValueRef = semantic['categoryValueRef'];
+
+    if (!categoryValueRef) {
+      return '';
+    }
+
+
+    return categoryValueRef.value || '';
+  }
+
+  /**
+   * @param {Element} element
+   *
+   * @return {string}
+   */
+  function getLabel(element) {
+    var semantic = element.businessObject,
+        attr = getLabelAttr(semantic);
+
+    if (attr) {
+
+      if (attr === 'categoryValueRef') {
+
+        return getCategoryValue(semantic);
+      }
+
+      return semantic[attr] || '';
+    }
+  }
+
+  function ensureImported(element, target) {
+
+    if (element.ownerDocument !== target.ownerDocument) {
+      try {
+
+        // may fail on webkit
+        return target.ownerDocument.importNode(element, true);
+      } catch (e) {
+
+        // ignore
+      }
+    }
+
+    return element;
+  }
+
+  /**
+   * appendTo utility
+   */
+
+
+  /**
+   * Append a node to a target element and return the appended node.
+   *
+   * @param  {SVGElement} element
+   * @param  {SVGElement} target
+   *
+   * @return {SVGElement} the appended node
+   */
+  function appendTo(element, target) {
+    return target.appendChild(ensureImported(element, target));
+  }
+
+  /**
+   * append utility
+   */
+
+
+  /**
+   * Append a node to an element
+   *
+   * @param  {SVGElement} element
+   * @param  {SVGElement} node
+   *
+   * @return {SVGElement} the element
+   */
+  function append(target, node) {
+    appendTo(node, target);
+    return target;
+  }
+
+  /**
+   * attribute accessor utility
+   */
+
+  var LENGTH_ATTR = 2;
 
   var CSS_PROPERTIES = {
     'alignment-baseline': 1,
@@ -1504,7 +1633,7 @@
    */
 
   var TEXT_ENTITIES = /([&<>]{1})/g;
-  var ATTR_ENTITIES = /([\n\r"]{1})/g;
+  var ATTR_ENTITIES = /([&<>\n\r"]{1})/g;
 
   var ENTITY_REPLACEMENT = {
     '&': '&amp;',
@@ -2017,7 +2146,7 @@
    * @returns {number}
    */
   function getWidth(bounds, overrides = {}) {
-    return has$2(overrides, 'width') ? overrides.width : bounds.width;
+    return has$5(overrides, 'width') ? overrides.width : bounds.width;
   }
 
   /**
@@ -2029,7 +2158,7 @@
    * @returns {number}
    */
   function getHeight(bounds, overrides = {}) {
-    return has$2(overrides, 'height') ? overrides.height : bounds.height;
+    return has$5(overrides, 'height') ? overrides.height : bounds.height;
   }
 
   function _mergeNamespaces$2(n, m) {
@@ -2057,15 +2186,15 @@
    * @return {T[]}
    */
 
-  const nativeToString$1 = Object.prototype.toString;
-  const nativeHasOwnProperty$1 = Object.prototype.hasOwnProperty;
+  const nativeToString$4 = Object.prototype.toString;
+  const nativeHasOwnProperty$3 = Object.prototype.hasOwnProperty;
 
-  function isUndefined$2(obj) {
+  function isUndefined$4(obj) {
     return obj === undefined;
   }
 
-  function isArray$2(obj) {
-    return nativeToString$1.call(obj) === '[object Array]';
+  function isArray$4(obj) {
+    return nativeToString$4.call(obj) === '[object Array]';
   }
 
   /**
@@ -2076,8 +2205,8 @@
    *
    * @return {Boolean}
    */
-  function has$1(target, key) {
-    return nativeHasOwnProperty$1.call(target, key);
+  function has$3(target, key) {
+    return nativeHasOwnProperty$3.call(target, key);
   }
 
 
@@ -2091,20 +2220,20 @@
    *
    * @return {T} return result that stopped the iteration
    */
-  function forEach$1(collection, iterator) {
+  function forEach$3(collection, iterator) {
 
     let val,
         result;
 
-    if (isUndefined$2(collection)) {
+    if (isUndefined$4(collection)) {
       return;
     }
 
-    const convertKey = isArray$2(collection) ? toNum$1 : identity$1;
+    const convertKey = isArray$4(collection) ? toNum$3 : identity$3;
 
     for (let key in collection) {
 
-      if (has$1(collection, key)) {
+      if (has$3(collection, key)) {
         val = collection[key];
 
         result = iterator(val, convertKey(key));
@@ -2117,11 +2246,11 @@
   }
 
 
-  function identity$1(arg) {
+  function identity$3(arg) {
     return arg;
   }
 
-  function toNum$1(arg) {
+  function toNum$3(arg) {
     return Number(arg);
   }
 
@@ -2133,15 +2262,15 @@
    *
    * @return {Element} the element
    */
-  function assign$1(element, ...styleSources) {
+  function assign$4(element, ...styleSources) {
     const target = element.style;
 
-    forEach$1(styleSources, function(style) {
+    forEach$3(styleSources, function(style) {
       if (!style) {
         return;
       }
 
-      forEach$1(style, function(value, key) {
+      forEach$3(style, function(value, key) {
         target[key] = value;
       });
     });
@@ -2371,7 +2500,7 @@
   // when delegating.
   var forceCaptureEvents$1 = [ 'focus', 'blur' ];
 
-  function bind$2(el, selector, type, fn, capture) {
+  function bind$3(el, selector, type, fn, capture) {
     if (forceCaptureEvents$1.indexOf(type) !== -1) {
       capture = true;
     }
@@ -2403,7 +2532,7 @@
   }
 
   var delegate$1 = {
-    bind: bind$2,
+    bind: bind$3,
     unbind: unbind$2
   };
 
@@ -2990,7 +3119,7 @@
 
     function drawCircle(parentGfx, width, height, offset, attrs = {}) {
 
-      if (isObject(offset)) {
+      if (isObject$2(offset)) {
         attrs = offset;
         offset = 0;
       }
@@ -3016,7 +3145,7 @@
 
     function drawRect(parentGfx, width, height, r, offset, attrs) {
 
-      if (isObject(offset)) {
+      if (isObject$2(offset)) {
         attrs = offset;
         offset = 0;
       }
@@ -3111,7 +3240,7 @@
     }
 
     function drawMarker(type, parentGfx, path, attrs) {
-      return drawPath(parentGfx, path, assign$2({ 'data-marker': type }, attrs));
+      return drawPath(parentGfx, path, assign$6({ 'data-marker': type }, attrs));
     }
 
     function renderer(type) {
@@ -3658,7 +3787,7 @@
         taskMarkers.push('AdhocMarker');
 
         if (!subprocess) {
-          assign$2(attrs, { compensation: attrs.compensation - 18 });
+          assign$6(attrs, { compensation: attrs.compensation - 18 });
         }
       }
 
@@ -3667,12 +3796,12 @@
 
       if (loopCharacteristics) {
 
-        assign$2(attrs, {
+        assign$6(attrs, {
           compensation: attrs.compensation - 18,
         });
 
         if (taskMarkers.includes('AdhocMarker')) {
-          assign$2(attrs, {
+          assign$6(attrs, {
             seq: -23,
             loop: -18,
             parallel: -24
@@ -3693,18 +3822,18 @@
       }
 
       if (taskMarkers.includes('CompensationMarker') && taskMarkers.length === 1) {
-        assign$2(attrs, {
+        assign$6(attrs, {
           compensation: -8
         });
       }
 
-      forEach$2(taskMarkers, function(marker) {
+      forEach$5(taskMarkers, function(marker) {
         renderTaskMarker(marker, parentGfx, element, attrs);
       });
     }
 
     function renderLabel(parentGfx, label, attrs = {}) {
-      attrs = assign$2({
+      attrs = assign$6({
         size: {
           width: 100
         }
@@ -3750,7 +3879,7 @@
       return renderLabel(parentGfx, getLabel(element), {
         box: box,
         fitBox: true,
-        style: assign$2(
+        style: assign$6(
           {},
           textRenderer.getExternalStyle(),
           {
@@ -5109,15 +5238,15 @@
    * @return {T[]}
    */
 
-  const nativeToString = Object.prototype.toString;
-  const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
+  const nativeToString$3 = Object.prototype.toString;
+  const nativeHasOwnProperty$2 = Object.prototype.hasOwnProperty;
 
-  function isUndefined$1(obj) {
+  function isUndefined$3(obj) {
     return obj === undefined;
   }
 
-  function isArray$1(obj) {
-    return nativeToString.call(obj) === '[object Array]';
+  function isArray$3(obj) {
+    return nativeToString$3.call(obj) === '[object Array]';
   }
 
   /**
@@ -5128,8 +5257,8 @@
    *
    * @return {Boolean}
    */
-  function has(target, key) {
-    return nativeHasOwnProperty.call(target, key);
+  function has$2(target, key) {
+    return nativeHasOwnProperty$2.call(target, key);
   }
 
 
@@ -5143,20 +5272,20 @@
    *
    * @return {T} return result that stopped the iteration
    */
-  function forEach(collection, iterator) {
+  function forEach$2(collection, iterator) {
 
     let val,
         result;
 
-    if (isUndefined$1(collection)) {
+    if (isUndefined$3(collection)) {
       return;
     }
 
-    const convertKey = isArray$1(collection) ? toNum : identity;
+    const convertKey = isArray$3(collection) ? toNum$2 : identity$2;
 
     for (let key in collection) {
 
-      if (has(collection, key)) {
+      if (has$2(collection, key)) {
         val = collection[key];
 
         result = iterator(val, convertKey(key));
@@ -5169,11 +5298,11 @@
   }
 
 
-  function identity(arg) {
+  function identity$2(arg) {
     return arg;
   }
 
-  function toNum(arg) {
+  function toNum$2(arg) {
     return Number(arg);
   }
 
@@ -5185,15 +5314,15 @@
    *
    * @return {Element} the element
    */
-  function assign(element, ...styleSources) {
+  function assign$3(element, ...styleSources) {
     const target = element.style;
 
-    forEach(styleSources, function(style) {
+    forEach$2(styleSources, function(style) {
       if (!style) {
         return;
       }
 
-      forEach(style, function(value, key) {
+      forEach$2(style, function(value, key) {
         target[key] = value;
       });
     });
@@ -5470,7 +5599,7 @@
   // when delegating.
   var forceCaptureEvents = [ 'focus', 'blur' ];
 
-  function bind(el, selector, type, fn, capture) {
+  function bind$2(el, selector, type, fn, capture) {
     if (forceCaptureEvents.indexOf(type) !== -1) {
       capture = true;
     }
@@ -5502,7 +5631,7 @@
   }
 
   var delegate = {
-    bind,
+    bind: bind$2,
     unbind
   };
 
@@ -5704,8 +5833,8 @@
    */
   function parsePadding(padding) {
 
-    if (isObject(padding)) {
-      return assign$2({ top: 0, left: 0, right: 0, bottom: 0 }, padding);
+    if (isObject$1(padding)) {
+      return assign$5({ top: 0, left: 0, right: 0, bottom: 0 }, padding);
     } else {
       return {
         top: padding,
@@ -5899,7 +6028,7 @@
         id: 'helper-svg'
       });
 
-      assign(helperSvg, {
+      assign$3(helperSvg, {
         visibility: 'hidden',
         position: 'fixed',
         width: 0,
@@ -5920,7 +6049,7 @@
    */
   function Text(config) {
 
-    this._config = assign$2({}, {
+    this._config = assign$5({}, {
       size: DEFAULT_LABEL_SIZE,
       padding: DEFAULT_BOX_PADDING,
       style: {},
@@ -5964,8 +6093,8 @@
    * } }
    */
   Text.prototype.layoutText = function(text, options) {
-    var box = assign$2({}, this._config.size, options.box),
-        style = assign$2({}, this._config.style, options.style),
+    var box = assign$5({}, this._config.size, options.box),
+        style = assign$5({}, this._config.style, options.style),
         align = parseAlign(options.align || this._config.align),
         padding = parsePadding(options.padding !== undefined ? options.padding : this._config.padding),
         fitBox = options.fitBox || false;
@@ -6021,7 +6150,7 @@
 
     // layout each line taking into account that parent
     // shape might resize to fit text size
-    forEach$2(layouted, function(line) {
+    forEach$4(layouted, function(line) {
 
       var x;
 
@@ -6103,7 +6232,7 @@
    */
   function TextRenderer(config) {
 
-    var defaultStyle = assign$2({
+    var defaultStyle = assign$6({
       fontFamily: 'Arial, sans-serif',
       fontSize: DEFAULT_FONT_SIZE,
       fontWeight: 'normal',
@@ -6112,7 +6241,7 @@
 
     var fontSize = parseInt(defaultStyle.fontSize, 10) - 1;
 
-    var externalStyle = assign$2({}, defaultStyle, {
+    var externalStyle = assign$6({}, defaultStyle, {
       fontSize: fontSize
     }, config && config.externalStyle || {});
 
@@ -6909,7 +7038,7 @@
    * @return {Object}
    */
   function elementData(semantic, di, attrs) {
-    return assign$2({
+    return assign$6({
       id: semantic.id,
       type: semantic.$type,
       businessObject: semantic,
@@ -7251,7 +7380,7 @@
   function getBBox(elements, stopRecursion) {
 
     stopRecursion = !!stopRecursion;
-    if (!isArray$3(elements)) {
+    if (!isArray$5(elements)) {
       elements = [ elements ];
     }
 
@@ -7260,7 +7389,7 @@
         maxX,
         maxY;
 
-    forEach$2(elements, function(element) {
+    forEach$4(elements, function(element) {
 
       // If element is a connection the bbox must be computed first
       var bbox = element;
@@ -7488,7 +7617,7 @@
     /**
      * @type {OverlaysConfigDefault}
      */
-    this._overlayDefaults = assign$2({
+    this._overlayDefaults = assign$5({
 
       // no show constraints
       show: null,
@@ -7550,11 +7679,11 @@
    */
   Overlays.prototype.get = function(search) {
 
-    if (isString(search)) {
+    if (isString$3(search)) {
       search = { id: search };
     }
 
-    if (isString(search.element)) {
+    if (isString$3(search.element)) {
       search.element = this._elementRegistry.get(search.element);
     }
 
@@ -7563,12 +7692,12 @@
 
       // return a list of overlays when searching by element (+type)
       if (container) {
-        return search.type ? filter(container.overlays, matchPattern({ type: search.type })) : container.overlays.slice();
+        return search.type ? filter$1(container.overlays, matchPattern({ type: search.type })) : container.overlays.slice();
       } else {
         return [];
       }
     } else if (search.type) {
-      return filter(this._overlays, matchPattern({ type: search.type }));
+      return filter$1(this._overlays, matchPattern({ type: search.type }));
     } else {
 
       // return single element when searching by id
@@ -7587,7 +7716,7 @@
    */
   Overlays.prototype.add = function(element, type, overlay) {
 
-    if (isObject(type)) {
+    if (isObject$1(type)) {
       overlay = type;
       type = null;
     }
@@ -7610,7 +7739,7 @@
 
     var id = this._ids.next();
 
-    overlay = assign$2({}, this._overlayDefaults, overlay, {
+    overlay = assign$5({}, this._overlayDefaults, overlay, {
       id: id,
       type: type,
       element: element,
@@ -7634,13 +7763,13 @@
 
     var overlays = this.get(filter) || [];
 
-    if (!isArray$3(overlays)) {
+    if (!isArray$5(overlays)) {
       overlays = [ overlays ];
     }
 
     var self = this;
 
-    forEach$2(overlays, function(overlay) {
+    forEach$4(overlays, function(overlay) {
 
       var container = self._getOverlayContainer(overlay.element, true);
 
@@ -7766,7 +7895,7 @@
 
   Overlays.prototype._createOverlayContainer = function(element) {
     var html = domify$1('<div class="djs-overlays" />');
-    assign(html, { position: 'absolute' });
+    assign$3(html, { position: 'absolute' });
 
     this._overlayRoot.appendChild(html);
 
@@ -7803,7 +7932,7 @@
 
 
   Overlays.prototype._getOverlayContainer = function(element, raw) {
-    var container = find(this._overlayContainers, function(c) {
+    var container = find$1(this._overlayContainers, function(c) {
       return c.element === element;
     });
 
@@ -7831,14 +7960,14 @@
 
     // create proper html elements from
     // overlay HTML strings
-    if (isString(html)) {
+    if (isString$3(html)) {
       html = domify$1(html);
     }
 
     overlayContainer = this._getOverlayContainer(element);
 
     htmlContainer = domify$1('<div class="djs-overlay" data-overlay-id="' + id + '">');
-    assign(htmlContainer, { position: 'absolute' });
+    assign$3(htmlContainer, { position: 'absolute' });
 
     htmlContainer.appendChild(html);
 
@@ -7876,8 +8005,8 @@
       visible = false;
     } else if (show) {
       if (
-        (isDefined(minZoom) && minZoom > viewbox.scale) ||
-        (isDefined(maxZoom) && maxZoom < viewbox.scale)
+        (isDefined$1(minZoom) && minZoom > viewbox.scale) ||
+        (isDefined$1(maxZoom) && maxZoom < viewbox.scale)
       ) {
         visible = false;
       }
@@ -7907,16 +8036,16 @@
         maxScale = shouldScale.max;
       }
 
-      if (isDefined(minScale) && viewbox.scale < minScale) {
+      if (isDefined$1(minScale) && viewbox.scale < minScale) {
         scale = (1 / viewbox.scale || 1) * minScale;
       }
 
-      if (isDefined(maxScale) && viewbox.scale > maxScale) {
+      if (isDefined$1(maxScale) && viewbox.scale > maxScale) {
         scale = (1 / viewbox.scale || 1) * maxScale;
       }
     }
 
-    if (isDefined(scale)) {
+    if (isDefined$1(scale)) {
       transform = 'scale(' + scale + ',' + scale + ')';
     }
 
@@ -7928,7 +8057,7 @@
 
     var self = this;
 
-    forEach$2(this._overlays, function(overlay) {
+    forEach$4(this._overlays, function(overlay) {
       self._updateOverlayVisibilty(overlay, viewbox);
     });
   };
@@ -7965,7 +8094,7 @@
       var element = e.element;
       var overlays = self.get({ element: element });
 
-      forEach$2(overlays, function(o) {
+      forEach$4(overlays, function(o) {
         self.remove(o.id);
       });
 
@@ -7989,7 +8118,7 @@
       var container = self._getOverlayContainer(element, true);
 
       if (container) {
-        forEach$2(container.overlays, function(overlay) {
+        forEach$4(container.overlays, function(overlay) {
           self._updateOverlay(overlay);
         });
 
@@ -8026,7 +8155,7 @@
       '<div class="djs-overlay-container" />'
     );
 
-    assign(root, {
+    assign$3(root, {
       position: 'absolute',
       width: 0,
       height: 0
@@ -8038,7 +8167,7 @@
   }
 
   function setPosition(el, x, y) {
-    assign(el, { left: x + 'px', top: y + 'px' });
+    assign$3(el, { left: x + 'px', top: y + 'px' });
   }
 
   /**
@@ -8212,7 +8341,7 @@
    */
   CommandInterceptor.prototype.on = function(events, hook, priority, handlerFn, unwrap, that) {
 
-    if (isFunction(hook) || isNumber(hook)) {
+    if (isFunction$1(hook) || isNumber(hook)) {
       that = unwrap;
       unwrap = handlerFn;
       handlerFn = priority;
@@ -8220,29 +8349,29 @@
       hook = null;
     }
 
-    if (isFunction(priority)) {
+    if (isFunction$1(priority)) {
       that = unwrap;
       unwrap = handlerFn;
       handlerFn = priority;
       priority = DEFAULT_PRIORITY$2;
     }
 
-    if (isObject(unwrap)) {
+    if (isObject$1(unwrap)) {
       that = unwrap;
       unwrap = false;
     }
 
-    if (!isFunction(handlerFn)) {
+    if (!isFunction$1(handlerFn)) {
       throw new Error('handlerFn must be a function');
     }
 
-    if (!isArray$3(events)) {
+    if (!isArray$5(events)) {
       events = [ events ];
     }
 
     var eventBus = this._eventBus;
 
-    forEach$2(events, function(event) {
+    forEach$4(events, function(event) {
 
       // concat commandStack(.event)?(.hook)?
       var fullEvent = [ 'commandStack', event, hook ].filter(function(e) { return e; }).join('.');
@@ -8376,7 +8505,7 @@
      */
     const hookFn = function(events, priority, handlerFn, unwrap, that) {
 
-      if (isFunction(events) || isNumber(events)) {
+      if (isFunction$1(events) || isNumber(events)) {
         that = unwrap;
         unwrap = handlerFn;
         handlerFn = priority;
@@ -8525,7 +8654,7 @@
       var shape = event.element,
           businessObject = getBusinessObject(shape);
 
-      var isPresent = find(businessObjectParents, function(element) {
+      var isPresent = find$2(businessObjectParents, function(element) {
         return element === businessObject;
       });
 
@@ -9491,13 +9620,13 @@
     }
 
     function registerEvents(svg) {
-      forEach$2(bindings, function(val, key) {
+      forEach$4(bindings, function(val, key) {
         registerEvent(svg, key, val);
       });
     }
 
     function unregisterEvents(svg) {
-      forEach$2(bindings, function(val, key) {
+      forEach$4(bindings, function(val, key) {
         unregisterEvent(svg, key, val);
       });
     }
@@ -9568,7 +9697,7 @@
 
     function createHitStyle(classNames, attrs) {
 
-      attrs = assign$2({
+      attrs = assign$5({
         stroke: 'white',
         strokeWidth: 15
       }, attrs || {});
@@ -9607,7 +9736,7 @@
     this.removeHits = function(gfx) {
       var hits = all('.djs-hit', gfx);
 
-      forEach$2(hits, remove$3);
+      forEach$4(hits, remove$3);
     };
 
     /**
@@ -9666,7 +9795,7 @@
      */
     this.createBoxHit = function(gfx, type, attrs) {
 
-      attrs = assign$2({
+      attrs = assign$5({
         x: 0,
         y: 0
       }, attrs);
@@ -9901,7 +10030,7 @@
     var selectedElements = this._selectedElements,
         oldSelection = selectedElements.slice();
 
-    if (!isArray$3(elements)) {
+    if (!isArray$5(elements)) {
       elements = elements ? [ elements ] : [];
     }
 
@@ -9918,7 +10047,7 @@
     // selection may be cleared by passing an empty array or null
     // to the method
     if (add) {
-      forEach$2(elements, function(element) {
+      forEach$4(elements, function(element) {
         if (selectedElements.indexOf(element) !== -1) {
 
           // already selected
@@ -9985,13 +10114,13 @@
       var oldSelection = event.oldSelection,
           newSelection = event.newSelection;
 
-      forEach$2(oldSelection, function(e) {
+      forEach$4(oldSelection, function(e) {
         if (newSelection.indexOf(e) === -1) {
           deselect(e);
         }
       });
 
-      forEach$2(newSelection, function(e) {
+      forEach$4(newSelection, function(e) {
         if (oldSelection.indexOf(e) === -1) {
           select(e);
         }
@@ -10034,7 +10163,7 @@
           return;
         }
 
-        if (isArray$3(autoSelect)) {
+        if (isArray$5(autoSelect)) {
           selection.select(autoSelect);
         } else {
 
@@ -10061,7 +10190,7 @@
       var shape = elementRegistry.get(event.context.shape.id);
 
       // Always select main shape on move
-      var isSelected = find(previousSelection, function(selectedShape) {
+      var isSelected = find$1(previousSelection, function(selectedShape) {
         return shape.id === selectedShape.id;
       });
 
@@ -10153,7 +10282,7 @@
    *
    * @return {boolean}
    */
-  function isArray(obj) {
+  function isArray$2(obj) {
     return Array.isArray(obj);
   }
 
@@ -10180,7 +10309,7 @@
    */
   function annotate(...args) {
 
-    if (args.length === 1 && isArray(args[0])) {
+    if (args.length === 1 && isArray$2(args[0])) {
       args = args[0];
     }
 
@@ -10325,7 +10454,7 @@
       }
 
       if (typeof fn !== 'function') {
-        if (isArray(fn)) {
+        if (isArray$2(fn)) {
           fn = annotate(fn.slice());
         } else {
           throw error(`Cannot invoke "${ fn }". Expected a function!`);
@@ -10624,7 +10753,7 @@
   // helpers ///////////////
 
   function arrayUnwrap(type, value) {
-    if (type !== 'value' && isArray(value)) {
+    if (type !== 'value' && isArray$2(value)) {
       value = annotate(value.slice());
     }
 
@@ -10679,9 +10808,9 @@
     });
 
     if (isFrameElement(element)) {
-      attr$1(rect, assign$2({}, this.FRAME_STYLE, attrs || {}));
+      attr$1(rect, assign$5({}, this.FRAME_STYLE, attrs || {}));
     } else {
-      attr$1(rect, assign$2({}, this.SHAPE_STYLE, attrs || {}));
+      attr$1(rect, assign$5({}, this.SHAPE_STYLE, attrs || {}));
     }
 
     append(visuals, rect);
@@ -10694,7 +10823,7 @@
    */
   DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection, attrs) {
 
-    var line = createLine(connection.waypoints, assign$2({}, this.CONNECTION_STYLE, attrs || {}));
+    var line = createLine(connection.waypoints, assign$5({}, this.CONNECTION_STYLE, attrs || {}));
     append(visuals, line);
 
     return line;
@@ -10776,7 +10905,7 @@
     this.cls = function(className, traits, additionalAttrs) {
       var attrs = this.style(traits, additionalAttrs);
 
-      return assign$2(attrs, { 'class': className });
+      return assign$5(attrs, { 'class': className });
     };
 
     /**
@@ -10790,16 +10919,16 @@
      */
     this.style = function(traits, additionalAttrs) {
 
-      if (!isArray$3(traits) && !additionalAttrs) {
+      if (!isArray$5(traits) && !additionalAttrs) {
         additionalAttrs = traits;
         traits = [];
       }
 
       var attrs = reduce(traits, function(attrs, t) {
-        return assign$2(attrs, defaultTraits[t] || {});
+        return assign$5(attrs, defaultTraits[t] || {});
       }, {});
 
-      return additionalAttrs ? assign$2(attrs, additionalAttrs) : attrs;
+      return additionalAttrs ? assign$5(attrs, additionalAttrs) : attrs;
     };
 
 
@@ -10814,12 +10943,12 @@
      * @return {Object} the style definition
      */
     this.computeStyle = function(custom, traits, defaultStyles) {
-      if (!isArray$3(traits)) {
+      if (!isArray$5(traits)) {
         defaultStyles = traits;
         traits = [];
       }
 
-      return self.style(traits || [], assign$2({}, defaultStyles, custom || {}));
+      return self.style(traits || [], assign$5({}, defaultStyles, custom || {}));
     };
   }
 
@@ -10974,7 +11103,7 @@
    */
   function createContainer(options) {
 
-    options = assign$2({}, { width: '100%', height: '100%' }, options);
+    options = assign$5({}, { width: '100%', height: '100%' }, options);
 
     const container = options.container || document.body;
 
@@ -10984,7 +11113,7 @@
     const parent = document.createElement('div');
     parent.setAttribute('class', 'djs-container djs-parent');
 
-    assign(parent, {
+    assign$3(parent, {
       position: 'relative',
       overflow: 'hidden',
       width: ensurePx(options.width),
@@ -11127,7 +11256,7 @@
     // debounce canvas.viewbox.changed events when deferUpdate is set
     // to help with potential performance issues
     if (config.deferUpdate) {
-      this._viewboxChanged = debounce(bind$3(this._viewboxChanged, this), 300);
+      this._viewboxChanged = debounce(bind$4(this._viewboxChanged, this), 300);
     }
 
     eventBus.on('diagram.init', () => {
@@ -11469,7 +11598,7 @@
   };
 
   Canvas.prototype._findPlaneForRoot = function(rootElement) {
-    return find(this._planes, function(plane) {
+    return find$1(this._planes, function(plane) {
       return plane.rootElement === rootElement;
     });
   };
@@ -11504,7 +11633,7 @@
       return;
     }
 
-    forEach$2([ container.gfx, container.secondaryGfx ], function(gfx) {
+    forEach$4([ container.gfx, container.secondaryGfx ], function(gfx) {
       if (gfx) {
 
         // invoke either addClass or removeClass based on mode
@@ -12162,7 +12291,7 @@
 
     if (delta) {
       this._changeViewbox(function() {
-        delta = assign$2({ dx: 0, dy: 0 }, delta || {});
+        delta = assign$5({ dx: 0, dy: 0 }, delta || {});
 
         matrix = this._svg.createSVGMatrix().translate(delta.dx, delta.dy).multiply(matrix);
 
@@ -12361,7 +12490,7 @@
     const currentScale = currentMatrix.a;
 
     if (center) {
-      centerPoint = assign$2(point, center);
+      centerPoint = assign$5(point, center);
 
       // revert applied viewport transformations
       originalPoint = centerPoint.matrixTransform(currentMatrix.inverse());
@@ -13301,7 +13430,7 @@
     if (!Type) {
       throw new Error('unknown type: <' + type + '>');
     }
-    return assign$2(new Type(), attrs);
+    return assign$5(new Type(), attrs);
   }
 
   /**
@@ -13401,7 +13530,7 @@
    */
   ElementFactory.prototype.create = function(type, attrs) {
 
-    attrs = assign$2({}, attrs || {});
+    attrs = assign$5({}, attrs || {});
 
     if (!attrs.id) {
       attrs.id = type + '_' + (this._uid++);
@@ -13579,9 +13708,9 @@
    */
   EventBus.prototype.on = function(events, priority, callback, that) {
 
-    events = isArray$3(events) ? events : [ events ];
+    events = isArray$5(events) ? events : [ events ];
 
-    if (isFunction(priority)) {
+    if (isFunction$1(priority)) {
       that = callback;
       callback = priority;
       priority = DEFAULT_PRIORITY$1;
@@ -13594,7 +13723,7 @@
     var actualCallback = callback;
 
     if (that) {
-      actualCallback = bind$3(callback, that);
+      actualCallback = bind$4(callback, that);
 
       // make sure we remember and are able to remove
       // bound callbacks via {@link #off} using the original
@@ -13638,7 +13767,7 @@
   EventBus.prototype.once = function(events, priority, callback, that) {
     var self = this;
 
-    if (isFunction(priority)) {
+    if (isFunction$1(priority)) {
       that = callback;
       callback = priority;
       priority = DEFAULT_PRIORITY$1;
@@ -13677,7 +13806,7 @@
    */
   EventBus.prototype.off = function(events, callback) {
 
-    events = isArray$3(events) ? events : [ events ];
+    events = isArray$5(events) ? events : [ events ];
 
     var self = this;
 
@@ -14002,7 +14131,7 @@
   };
 
   InternalEvent.prototype.init = function(data) {
-    assign$2(this, data || {});
+    assign$5(this, data || {});
   };
 
 
@@ -14201,7 +14330,7 @@
 
     // update all parents of changed and reorganized their children
     // in the correct order (as indicated in our model)
-    forEach$2(parents, function(parent) {
+    forEach$4(parents, function(parent) {
 
       var children = parent.children;
 
@@ -14211,7 +14340,7 @@
 
       var childrenGfx = self._getChildrenContainer(parent);
 
-      forEach$2(children.slice().reverse(), function(child) {
+      forEach$4(children.slice().reverse(), function(child) {
         var childGfx = elementRegistry.getGraphics(child);
 
         prependTo(childGfx.parentNode, childrenGfx);
@@ -14581,6 +14710,231 @@
     this.get('eventBus').fire('diagram.clear');
   };
 
+  /**
+   * Flatten array, one level deep.
+   *
+   * @template T
+   *
+   * @param {T[][] | T[] | null} [arr]
+   *
+   * @return {T[]}
+   */
+
+  const nativeToString$2 = Object.prototype.toString;
+
+  function isString$2(obj) {
+    return nativeToString$2.call(obj) === '[object String]';
+  }
+
+  /**
+   * Convenience wrapper for `Object.assign`.
+   *
+   * @param {Object} target
+   * @param {...Object} others
+   *
+   * @return {Object} the target
+   */
+  function assign$2(target, ...others) {
+    return Object.assign(target, ...others);
+  }
+
+  /**
+   * Flatten array, one level deep.
+   *
+   * @template T
+   *
+   * @param {T[][] | T[] | null} [arr]
+   *
+   * @return {T[]}
+   */
+
+  const nativeToString$1 = Object.prototype.toString;
+  const nativeHasOwnProperty$1 = Object.prototype.hasOwnProperty;
+
+  function isUndefined$2(obj) {
+    return obj === undefined;
+  }
+
+  function isDefined(obj) {
+    return obj !== undefined;
+  }
+
+  function isNil$1(obj) {
+    return obj == null;
+  }
+
+  function isArray$1(obj) {
+    return nativeToString$1.call(obj) === '[object Array]';
+  }
+
+  function isObject(obj) {
+    return nativeToString$1.call(obj) === '[object Object]';
+  }
+
+  function isString$1(obj) {
+    return nativeToString$1.call(obj) === '[object String]';
+  }
+
+  /**
+   * Return true, if target owns a property with the given key.
+   *
+   * @param {Object} target
+   * @param {String} key
+   *
+   * @return {Boolean}
+   */
+  function has$1(target, key) {
+    return !isNil$1(target) && nativeHasOwnProperty$1.call(target, key);
+  }
+
+
+  /**
+   * Iterate over collection; returning something
+   * (non-undefined) will stop iteration.
+   *
+   * @template T
+   * @param {Collection<T>} collection
+   * @param { ((item: T, idx: number) => (boolean|void)) | ((item: T, key: string) => (boolean|void)) } iterator
+   *
+   * @return {T} return result that stopped the iteration
+   */
+  function forEach$1(collection, iterator) {
+
+    let val,
+        result;
+
+    if (isUndefined$2(collection)) {
+      return;
+    }
+
+    const convertKey = isArray$1(collection) ? toNum$1 : identity$1;
+
+    for (let key in collection) {
+
+      if (has$1(collection, key)) {
+        val = collection[key];
+
+        result = iterator(val, convertKey(key));
+
+        if (result === false) {
+          return val;
+        }
+      }
+    }
+  }
+
+
+  function identity$1(arg) {
+    return arg;
+  }
+
+  function toNum$1(arg) {
+    return Number(arg);
+  }
+
+  /**
+   * Bind function against target <this>.
+   *
+   * @param  {Function} fn
+   * @param  {Object}   target
+   *
+   * @return {Function} bound function
+   */
+  function bind(fn, target) {
+    return fn.bind(target);
+  }
+
+  /**
+   * Convenience wrapper for `Object.assign`.
+   *
+   * @param {Object} target
+   * @param {...Object} others
+   *
+   * @return {Object} the target
+   */
+  function assign$1(target, ...others) {
+    return Object.assign(target, ...others);
+  }
+
+  /**
+   * Sets a nested property of a given object to the specified value.
+   *
+   * This mutates the object and returns it.
+   *
+   * @template T
+   *
+   * @param {T} target The target of the set operation.
+   * @param {(string|number)[]} path The path to the nested value.
+   * @param {any} value The value to set.
+   *
+   * @return {T}
+   */
+  function set$1(target, path, value) {
+
+    let currentTarget = target;
+
+    forEach$1(path, function(key, idx) {
+
+      if (typeof key !== 'number' && typeof key !== 'string') {
+        throw new Error('illegal key type: ' + typeof key + '. Key should be of type number or string.');
+      }
+
+      if (key === 'constructor') {
+        throw new Error('illegal key: constructor');
+      }
+
+      if (key === '__proto__') {
+        throw new Error('illegal key: __proto__');
+      }
+
+      let nextKey = path[idx + 1];
+      let nextTarget = currentTarget[key];
+
+      if (isDefined(nextKey) && isNil$1(nextTarget)) {
+        nextTarget = currentTarget[key] = isNaN(+nextKey) ? {} : [];
+      }
+
+      if (isUndefined$2(nextKey)) {
+        if (isUndefined$2(value)) {
+          delete currentTarget[key];
+        } else {
+          currentTarget[key] = value;
+        }
+      } else {
+        currentTarget = nextTarget;
+      }
+    });
+
+    return target;
+  }
+
+  /**
+   * Pick properties from the given target.
+   *
+   * @template T
+   * @template {any[]} V
+   *
+   * @param {T} target
+   * @param {V} properties
+   *
+   * @return Pick<T, V>
+   */
+  function pick(target, properties) {
+
+    let result = {};
+
+    let obj = Object(target);
+
+    forEach$1(properties, function(prop) {
+
+      if (prop in obj) {
+        result[prop] = target[prop];
+      }
+    });
+
+    return result;
+  }
+
   /**
    * Moddle base element.
    */
@@ -14614,7 +14968,7 @@
         prototype = Object.create(Base.prototype);
 
     // initialize default values
-    forEach$2(descriptor.properties, function(p) {
+    forEach$1(descriptor.properties, function(p) {
       if (!p.isMany && p.default !== undefined) {
         prototype[p.name] = p.default;
       }
@@ -14633,7 +14987,7 @@
       props.define(this, '$attrs', { value: {} });
       props.define(this, '$parent', { writable: true });
 
-      forEach$2(attrs, bind$3(function(val, key) {
+      forEach$1(attrs, bind(function(val, key) {
         this.set(key, val);
       }, this));
     }
@@ -14846,736 +15200,994 @@
     var name = parseName(parts[0], nsPrefix);
     var attrName = parseName(parts[1], name.prefix).name;
 
-    var redefinedProperty = this.propertiesByName[attrName];
-    if (!redefinedProperty) {
-      throw new Error('refined property <' + attrName + '> not found');
-    } else {
-      this.replaceProperty(redefinedProperty, p, replace);
+    var redefinedProperty = this.propertiesByName[attrName];
+    if (!redefinedProperty) {
+      throw new Error('refined property <' + attrName + '> not found');
+    } else {
+      this.replaceProperty(redefinedProperty, p, replace);
+    }
+
+    delete p.redefines;
+  };
+
+  DescriptorBuilder.prototype.addNamedProperty = function(p, validate) {
+    var ns = p.ns,
+        propsByName = this.propertiesByName;
+
+    if (validate) {
+      this.assertNotDefined(p, ns.name);
+      this.assertNotDefined(p, ns.localName);
+    }
+
+    propsByName[ns.name] = propsByName[ns.localName] = p;
+  };
+
+  DescriptorBuilder.prototype.removeNamedProperty = function(p) {
+    var ns = p.ns,
+        propsByName = this.propertiesByName;
+
+    delete propsByName[ns.name];
+    delete propsByName[ns.localName];
+  };
+
+  DescriptorBuilder.prototype.setBodyProperty = function(p, validate) {
+
+    if (validate && this.bodyProperty) {
+      throw new Error(
+        'body property defined multiple times ' +
+        '(<' + this.bodyProperty.ns.name + '>, <' + p.ns.name + '>)');
+    }
+
+    this.bodyProperty = p;
+  };
+
+  DescriptorBuilder.prototype.setIdProperty = function(p, validate) {
+
+    if (validate && this.idProperty) {
+      throw new Error(
+        'id property defined multiple times ' +
+        '(<' + this.idProperty.ns.name + '>, <' + p.ns.name + '>)');
+    }
+
+    this.idProperty = p;
+  };
+
+  DescriptorBuilder.prototype.assertNotTrait = function(typeDescriptor) {
+
+    const _extends = typeDescriptor.extends || [];
+
+    if (_extends.length) {
+      throw new Error(
+        `cannot create <${ typeDescriptor.name }> extending <${ typeDescriptor.extends }>`
+      );
+    }
+  };
+
+  DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
+    var propertyName = p.name,
+        definedProperty = this.propertiesByName[propertyName];
+
+    if (definedProperty) {
+      throw new Error(
+        'property <' + propertyName + '> already defined; ' +
+        'override of <' + definedProperty.definedBy.ns.name + '#' + definedProperty.ns.name + '> by ' +
+        '<' + p.definedBy.ns.name + '#' + p.ns.name + '> not allowed without redefines');
+    }
+  };
+
+  DescriptorBuilder.prototype.hasProperty = function(name) {
+    return this.propertiesByName[name];
+  };
+
+  DescriptorBuilder.prototype.addTrait = function(t, inherited) {
+
+    if (inherited) {
+      this.assertNotTrait(t);
+    }
+
+    var typesByName = this.allTypesByName,
+        types = this.allTypes;
+
+    var typeName = t.name;
+
+    if (typeName in typesByName) {
+      return;
+    }
+
+    forEach$1(t.properties, bind(function(p) {
+
+      // clone property to allow extensions
+      p = assign$1({}, p, {
+        name: p.ns.localName,
+        inherited: inherited
+      });
+
+      Object.defineProperty(p, 'definedBy', {
+        value: t
+      });
+
+      var replaces = p.replaces,
+          redefines = p.redefines;
+
+      // add replace/redefine support
+      if (replaces || redefines) {
+        this.redefineProperty(p, replaces || redefines, replaces);
+      } else {
+        if (p.isBody) {
+          this.setBodyProperty(p);
+        }
+        if (p.isId) {
+          this.setIdProperty(p);
+        }
+        this.addProperty(p);
+      }
+    }, this));
+
+    types.push(t);
+    typesByName[typeName] = t;
+  };
+
+  /**
+   * A registry of Moddle packages.
+   *
+   * @param {Array<Package>} packages
+   * @param {Properties} properties
+   */
+  function Registry(packages, properties) {
+    this.packageMap = {};
+    this.typeMap = {};
+
+    this.packages = [];
+
+    this.properties = properties;
+
+    forEach$1(packages, bind(this.registerPackage, this));
+  }
+
+
+  Registry.prototype.getPackage = function(uriOrPrefix) {
+    return this.packageMap[uriOrPrefix];
+  };
+
+  Registry.prototype.getPackages = function() {
+    return this.packages;
+  };
+
+
+  Registry.prototype.registerPackage = function(pkg) {
+
+    // copy package
+    pkg = assign$1({}, pkg);
+
+    var pkgMap = this.packageMap;
+
+    ensureAvailable(pkgMap, pkg, 'prefix');
+    ensureAvailable(pkgMap, pkg, 'uri');
+
+    // register types
+    forEach$1(pkg.types, bind(function(descriptor) {
+      this.registerType(descriptor, pkg);
+    }, this));
+
+    pkgMap[pkg.uri] = pkgMap[pkg.prefix] = pkg;
+    this.packages.push(pkg);
+  };
+
+
+  /**
+   * Register a type from a specific package with us
+   */
+  Registry.prototype.registerType = function(type, pkg) {
+
+    type = assign$1({}, type, {
+      superClass: (type.superClass || []).slice(),
+      extends: (type.extends || []).slice(),
+      properties: (type.properties || []).slice(),
+      meta: assign$1((type.meta || {}))
+    });
+
+    var ns = parseName(type.name, pkg.prefix),
+        name = ns.name,
+        propertiesByName = {};
+
+    // parse properties
+    forEach$1(type.properties, bind(function(p) {
+
+      // namespace property names
+      var propertyNs = parseName(p.name, ns.prefix),
+          propertyName = propertyNs.name;
+
+      // namespace property types
+      if (!isBuiltIn(p.type)) {
+        p.type = parseName(p.type, propertyNs.prefix).name;
+      }
+
+      assign$1(p, {
+        ns: propertyNs,
+        name: propertyName
+      });
+
+      propertiesByName[propertyName] = p;
+    }, this));
+
+    // update ns + name
+    assign$1(type, {
+      ns: ns,
+      name: name,
+      propertiesByName: propertiesByName
+    });
+
+    forEach$1(type.extends, bind(function(extendsName) {
+      var extendsNameNs = parseName(extendsName, ns.prefix);
+
+      var extended = this.typeMap[extendsNameNs.name];
+
+      extended.traits = extended.traits || [];
+      extended.traits.push(name);
+    }, this));
+
+    // link to package
+    this.definePackage(type, pkg);
+
+    // register
+    this.typeMap[name] = type;
+  };
+
+
+  /**
+   * Traverse the type hierarchy from bottom to top,
+   * calling iterator with (type, inherited) for all elements in
+   * the inheritance chain.
+   *
+   * @param {Object} nsName
+   * @param {Function} iterator
+   * @param {Boolean} [trait=false]
+   */
+  Registry.prototype.mapTypes = function(nsName, iterator, trait) {
+
+    var type = isBuiltIn(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];
+
+    var self = this;
+
+    /**
+     * Traverse the selected super type or trait
+     *
+     * @param {String} cls
+     * @param {Boolean} [trait=false]
+     */
+    function traverse(cls, trait) {
+      var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
+      self.mapTypes(parentNs, iterator, trait);
+    }
+
+    /**
+     * Traverse the selected trait.
+     *
+     * @param {String} cls
+     */
+    function traverseTrait(cls) {
+      return traverse(cls, true);
+    }
+
+    /**
+     * Traverse the selected super type
+     *
+     * @param {String} cls
+     */
+    function traverseSuper(cls) {
+      return traverse(cls, false);
     }
 
-    delete p.redefines;
-  };
+    if (!type) {
+      throw new Error('unknown type <' + nsName.name + '>');
+    }
 
-  DescriptorBuilder.prototype.addNamedProperty = function(p, validate) {
-    var ns = p.ns,
-        propsByName = this.propertiesByName;
+    forEach$1(type.superClass, trait ? traverseTrait : traverseSuper);
 
-    if (validate) {
-      this.assertNotDefined(p, ns.name);
-      this.assertNotDefined(p, ns.localName);
-    }
+    // call iterator with (type, inherited=!trait)
+    iterator(type, !trait);
 
-    propsByName[ns.name] = propsByName[ns.localName] = p;
+    forEach$1(type.traits, traverseTrait);
   };
 
-  DescriptorBuilder.prototype.removeNamedProperty = function(p) {
-    var ns = p.ns,
-        propsByName = this.propertiesByName;
 
-    delete propsByName[ns.name];
-    delete propsByName[ns.localName];
-  };
+  /**
+   * Returns the effective descriptor for a type.
+   *
+   * @param  {String} type the namespaced name (ns:localName) of the type
+   *
+   * @return {Descriptor} the resulting effective descriptor
+   */
+  Registry.prototype.getEffectiveDescriptor = function(name) {
 
-  DescriptorBuilder.prototype.setBodyProperty = function(p, validate) {
+    var nsName = parseName(name);
 
-    if (validate && this.bodyProperty) {
-      throw new Error(
-        'body property defined multiple times ' +
-        '(<' + this.bodyProperty.ns.name + '>, <' + p.ns.name + '>)');
-    }
+    var builder = new DescriptorBuilder(nsName);
 
-    this.bodyProperty = p;
-  };
+    this.mapTypes(nsName, function(type, inherited) {
+      builder.addTrait(type, inherited);
+    });
 
-  DescriptorBuilder.prototype.setIdProperty = function(p, validate) {
+    var descriptor = builder.build();
 
-    if (validate && this.idProperty) {
-      throw new Error(
-        'id property defined multiple times ' +
-        '(<' + this.idProperty.ns.name + '>, <' + p.ns.name + '>)');
-    }
+    // define package link
+    this.definePackage(descriptor, descriptor.allTypes[descriptor.allTypes.length - 1].$pkg);
 
-    this.idProperty = p;
+    return descriptor;
   };
 
-  DescriptorBuilder.prototype.assertNotTrait = function(typeDescriptor) {
-
-    const _extends = typeDescriptor.extends || [];
 
-    if (_extends.length) {
-      throw new Error(
-        `cannot create <${ typeDescriptor.name }> extending <${ typeDescriptor.extends }>`
-      );
-    }
+  Registry.prototype.definePackage = function(target, pkg) {
+    this.properties.define(target, '$pkg', { value: pkg });
   };
 
-  DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
-    var propertyName = p.name,
-        definedProperty = this.propertiesByName[propertyName];
 
-    if (definedProperty) {
-      throw new Error(
-        'property <' + propertyName + '> already defined; ' +
-        'override of <' + definedProperty.definedBy.ns.name + '#' + definedProperty.ns.name + '> by ' +
-        '<' + p.definedBy.ns.name + '#' + p.ns.name + '> not allowed without redefines');
-    }
-  };
 
-  DescriptorBuilder.prototype.hasProperty = function(name) {
-    return this.propertiesByName[name];
-  };
+  // helpers ////////////////////////////
 
-  DescriptorBuilder.prototype.addTrait = function(t, inherited) {
+  function ensureAvailable(packageMap, pkg, identifierKey) {
 
-    if (inherited) {
-      this.assertNotTrait(t);
+    var value = pkg[identifierKey];
+
+    if (value in packageMap) {
+      throw new Error('package with ' + identifierKey + ' <' + value + '> already defined');
     }
+  }
 
-    var typesByName = this.allTypesByName,
-        types = this.allTypes;
+  /**
+   * A utility that gets and sets properties of model elements.
+   *
+   * @param {Model} model
+   */
+  function Properties(model) {
+    this.model = model;
+  }
 
-    var typeName = t.name;
 
-    if (typeName in typesByName) {
-      return;
-    }
+  /**
+   * Sets a named property on the target element.
+   * If the value is undefined, the property gets deleted.
+   *
+   * @param {Object} target
+   * @param {String} name
+   * @param {Object} value
+   */
+  Properties.prototype.set = function(target, name, value) {
 
-    forEach$2(t.properties, bind$3(function(p) {
+    if (!isString$1(name) || !name.length) {
+      throw new TypeError('property name must be a non-empty string');
+    }
 
-      // clone property to allow extensions
-      p = assign$2({}, p, {
-        name: p.ns.localName,
-        inherited: inherited
-      });
+    var property = this.getProperty(target, name);
 
-      Object.defineProperty(p, 'definedBy', {
-        value: t
-      });
+    var propertyName = property && property.name;
 
-      var replaces = p.replaces,
-          redefines = p.redefines;
+    if (isUndefined$1(value)) {
 
-      // add replace/redefine support
-      if (replaces || redefines) {
-        this.redefineProperty(p, replaces || redefines, replaces);
+      // unset the property, if the specified value is undefined;
+      // delete from $attrs (for extensions) or the target itself
+      if (property) {
+        delete target[propertyName];
       } else {
-        if (p.isBody) {
-          this.setBodyProperty(p);
-        }
-        if (p.isId) {
-          this.setIdProperty(p);
-        }
-        this.addProperty(p);
+        delete target.$attrs[stripGlobal(name)];
       }
-    }, this));
+    } else {
 
-    types.push(t);
-    typesByName[typeName] = t;
+      // set the property, defining well defined properties on the fly
+      // or simply updating them in target.$attrs (for extensions)
+      if (property) {
+        if (propertyName in target) {
+          target[propertyName] = value;
+        } else {
+          defineProperty(target, property, value);
+        }
+      } else {
+        target.$attrs[stripGlobal(name)] = value;
+      }
+    }
   };
 
   /**
-   * A registry of Moddle packages.
+   * Returns the named property of the given element
    *
-   * @param {Array<Package>} packages
-   * @param {Properties} properties
+   * @param  {Object} target
+   * @param  {String} name
+   *
+   * @return {Object}
    */
-  function Registry(packages, properties) {
-    this.packageMap = {};
-    this.typeMap = {};
-
-    this.packages = [];
+  Properties.prototype.get = function(target, name) {
 
-    this.properties = properties;
+    var property = this.getProperty(target, name);
 
-    forEach$2(packages, bind$3(this.registerPackage, this));
-  }
+    if (!property) {
+      return target.$attrs[stripGlobal(name)];
+    }
 
+    var propertyName = property.name;
 
-  Registry.prototype.getPackage = function(uriOrPrefix) {
-    return this.packageMap[uriOrPrefix];
-  };
+    // check if access to collection property and lazily initialize it
+    if (!target[propertyName] && property.isMany) {
+      defineProperty(target, property, []);
+    }
 
-  Registry.prototype.getPackages = function() {
-    return this.packages;
+    return target[propertyName];
   };
 
 
-  Registry.prototype.registerPackage = function(pkg) {
+  /**
+   * Define a property on the target element
+   *
+   * @param  {Object} target
+   * @param  {String} name
+   * @param  {Object} options
+   */
+  Properties.prototype.define = function(target, name, options) {
 
-    // copy package
-    pkg = assign$2({}, pkg);
+    if (!options.writable) {
 
-    var pkgMap = this.packageMap;
+      var value = options.value;
 
-    ensureAvailable(pkgMap, pkg, 'prefix');
-    ensureAvailable(pkgMap, pkg, 'uri');
+      // use getters for read-only variables to support ES6 proxies
+      // cf. https://github.com/bpmn-io/internal-docs/issues/386
+      options = assign$1({}, options, {
+        get: function() { return value; }
+      });
 
-    // register types
-    forEach$2(pkg.types, bind$3(function(descriptor) {
-      this.registerType(descriptor, pkg);
-    }, this));
+      delete options.value;
+    }
 
-    pkgMap[pkg.uri] = pkgMap[pkg.prefix] = pkg;
-    this.packages.push(pkg);
+    Object.defineProperty(target, name, options);
   };
 
 
   /**
-   * Register a type from a specific package with us
+   * Define the descriptor for an element
    */
-  Registry.prototype.registerType = function(type, pkg) {
+  Properties.prototype.defineDescriptor = function(target, descriptor) {
+    this.define(target, '$descriptor', { value: descriptor });
+  };
 
-    type = assign$2({}, type, {
-      superClass: (type.superClass || []).slice(),
-      extends: (type.extends || []).slice(),
-      properties: (type.properties || []).slice(),
-      meta: assign$2((type.meta || {}))
-    });
+  /**
+   * Define the model for an element
+   */
+  Properties.prototype.defineModel = function(target, model) {
+    this.define(target, '$model', { value: model });
+  };
 
-    var ns = parseName(type.name, pkg.prefix),
-        name = ns.name,
-        propertiesByName = {};
+  /**
+   * Return property with the given name on the element.
+   *
+   * @param {any} target
+   * @param {string} name
+   *
+   * @return {object | null} property
+   */
+  Properties.prototype.getProperty = function(target, name) {
+
+    var model = this.model;
 
-    // parse properties
-    forEach$2(type.properties, bind$3(function(p) {
+    var property = model.getPropertyDescriptor(target, name);
 
-      // namespace property names
-      var propertyNs = parseName(p.name, ns.prefix),
-          propertyName = propertyNs.name;
+    if (property) {
+      return property;
+    }
 
-      // namespace property types
-      if (!isBuiltIn(p.type)) {
-        p.type = parseName(p.type, propertyNs.prefix).name;
-      }
+    if (name.includes(':')) {
+      return null;
+    }
 
-      assign$2(p, {
-        ns: propertyNs,
-        name: propertyName
-      });
+    const strict = model.config.strict;
 
-      propertiesByName[propertyName] = p;
-    }, this));
+    if (typeof strict !== 'undefined') {
+      const error = new TypeError(`unknown property <${ name }> on <${ target.$type }>`);
 
-    // update ns + name
-    assign$2(type, {
-      ns: ns,
-      name: name,
-      propertiesByName: propertiesByName
-    });
+      if (strict) {
+        throw error;
+      } else {
 
-    forEach$2(type.extends, bind$3(function(extendsName) {
-      var extendsNameNs = parseName(extendsName, ns.prefix);
+        // eslint-disable-next-line no-undef
+        typeof console !== 'undefined' && console.warn(error);
+      }
+    }
 
-      var extended = this.typeMap[extendsNameNs.name];
+    return null;
+  };
 
-      extended.traits = extended.traits || [];
-      extended.traits.push(name);
-    }, this));
+  function isUndefined$1(val) {
+    return typeof val === 'undefined';
+  }
 
-    // link to package
-    this.definePackage(type, pkg);
+  function defineProperty(target, property, value) {
+    Object.defineProperty(target, property.name, {
+      enumerable: !property.isReference,
+      writable: true,
+      value: value,
+      configurable: true
+    });
+  }
 
-    // register
-    this.typeMap[name] = type;
-  };
+  function stripGlobal(name) {
+    return name.replace(/^:/, '');
+  }
 
+  // Moddle implementation /////////////////////////////////////////////////
 
   /**
-   * Traverse the type hierarchy from bottom to top,
-   * calling iterator with (type, inherited) for all elements in
-   * the inheritance chain.
+   * @class Moddle
    *
-   * @param {Object} nsName
-   * @param {Function} iterator
-   * @param {Boolean} [trait=false]
+   * A model that can be used to create elements of a specific type.
+   *
+   * @example
+   *
+   * var Moddle = require('moddle');
+   *
+   * var pkg = {
+   *   name: 'mypackage',
+   *   prefix: 'my',
+   *   types: [
+   *     { name: 'Root' }
+   *   ]
+   * };
+   *
+   * var moddle = new Moddle([pkg]);
+   *
+   * @param {Array<Package>} packages the packages to contain
+   *
+   * @param { { strict?: boolean } } [config] moddle configuration
    */
-  Registry.prototype.mapTypes = function(nsName, iterator, trait) {
-
-    var type = isBuiltIn(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];
+  function Moddle(packages, config = {}) {
 
-    var self = this;
+    this.properties = new Properties(this);
 
-    /**
-     * Traverse the selected super type or trait
-     *
-     * @param {String} cls
-     * @param {Boolean} [trait=false]
-     */
-    function traverse(cls, trait) {
-      var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
-      self.mapTypes(parentNs, iterator, trait);
-    }
+    this.factory = new Factory(this, this.properties);
+    this.registry = new Registry(packages, this.properties);
 
-    /**
-     * Traverse the selected trait.
-     *
-     * @param {String} cls
-     */
-    function traverseTrait(cls) {
-      return traverse(cls, true);
-    }
+    this.typeCache = {};
 
-    /**
-     * Traverse the selected super type
-     *
-     * @param {String} cls
-     */
-    function traverseSuper(cls) {
-      return traverse(cls, false);
-    }
+    this.config = config;
+  }
 
-    if (!type) {
-      throw new Error('unknown type <' + nsName.name + '>');
-    }
 
-    forEach$2(type.superClass, trait ? traverseTrait : traverseSuper);
+  /**
+   * Create an instance of the specified type.
+   *
+   * @method Moddle#create
+   *
+   * @example
+   *
+   * var foo = moddle.create('my:Foo');
+   * var bar = moddle.create('my:Bar', { id: 'BAR_1' });
+   *
+   * @param  {String|Object} descriptor the type descriptor or name know to the model
+   * @param  {Object} attrs   a number of attributes to initialize the model instance with
+   * @return {Object}         model instance
+   */
+  Moddle.prototype.create = function(descriptor, attrs) {
+    var Type = this.getType(descriptor);
 
-    // call iterator with (type, inherited=!trait)
-    iterator(type, !trait);
+    if (!Type) {
+      throw new Error('unknown type <' + descriptor + '>');
+    }
 
-    forEach$2(type.traits, traverseTrait);
+    return new Type(attrs);
   };
 
 
   /**
-   * Returns the effective descriptor for a type.
+   * Returns the type representing a given descriptor
    *
-   * @param  {String} type the namespaced name (ns:localName) of the type
+   * @method Moddle#getType
    *
-   * @return {Descriptor} the resulting effective descriptor
+   * @example
+   *
+   * var Foo = moddle.getType('my:Foo');
+   * var foo = new Foo({ 'id' : 'FOO_1' });
+   *
+   * @param  {String|Object} descriptor the type descriptor or name know to the model
+   * @return {Object}         the type representing the descriptor
    */
-  Registry.prototype.getEffectiveDescriptor = function(name) {
-
-    var nsName = parseName(name);
+  Moddle.prototype.getType = function(descriptor) {
 
-    var builder = new DescriptorBuilder(nsName);
+    var cache = this.typeCache;
 
-    this.mapTypes(nsName, function(type, inherited) {
-      builder.addTrait(type, inherited);
-    });
+    var name = isString$1(descriptor) ? descriptor : descriptor.ns.name;
 
-    var descriptor = builder.build();
+    var type = cache[name];
 
-    // define package link
-    this.definePackage(descriptor, descriptor.allTypes[descriptor.allTypes.length - 1].$pkg);
+    if (!type) {
+      descriptor = this.registry.getEffectiveDescriptor(name);
+      type = cache[name] = this.factory.createType(descriptor);
+    }
 
-    return descriptor;
+    return type;
   };
 
 
-  Registry.prototype.definePackage = function(target, pkg) {
-    this.properties.define(target, '$pkg', { value: pkg });
-  };
+  /**
+   * Creates an any-element type to be used within model instances.
+   *
+   * This can be used to create custom elements that lie outside the meta-model.
+   * The created element contains all the meta-data required to serialize it
+   * as part of meta-model elements.
+   *
+   * @method Moddle#createAny
+   *
+   * @example
+   *
+   * var foo = moddle.createAny('vendor:Foo', 'http://vendor', {
+   *   value: 'bar'
+   * });
+   *
+   * var container = moddle.create('my:Container', 'http://my', {
+   *   any: [ foo ]
+   * });
+   *
+   * // go ahead and serialize the stuff
+   *
+   *
+   * @param  {String} name  the name of the element
+   * @param  {String} nsUri the namespace uri of the element
+   * @param  {Object} [properties] a map of properties to initialize the instance with
+   * @return {Object} the any type instance
+   */
+  Moddle.prototype.createAny = function(name, nsUri, properties) {
+
+    var nameNs = parseName(name);
 
+    var element = {
+      $type: name,
+      $instanceOf: function(type) {
+        return type === this.$type;
+      },
+      get: function(key) {
+        return this[key];
+      },
+      set: function(key, value) {
+        set$1(this, [ key ], value);
+      }
+    };
 
+    var descriptor = {
+      name: name,
+      isGeneric: true,
+      ns: {
+        prefix: nameNs.prefix,
+        localName: nameNs.localName,
+        uri: nsUri
+      }
+    };
 
-  // helpers ////////////////////////////
+    this.properties.defineDescriptor(element, descriptor);
+    this.properties.defineModel(element, this);
+    this.properties.define(element, 'get', { enumerable: false, writable: true });
+    this.properties.define(element, 'set', { enumerable: false, writable: true });
+    this.properties.define(element, '$parent', { enumerable: false, writable: true });
+    this.properties.define(element, '$instanceOf', { enumerable: false, writable: true });
 
-  function ensureAvailable(packageMap, pkg, identifierKey) {
+    forEach$1(properties, function(a, key) {
+      if (isObject(a) && a.value !== undefined) {
+        element[a.name] = a.value;
+      } else {
+        element[key] = a;
+      }
+    });
 
-    var value = pkg[identifierKey];
+    return element;
+  };
 
-    if (value in packageMap) {
-      throw new Error('package with ' + identifierKey + ' <' + value + '> already defined');
-    }
-  }
+  /**
+   * Returns a registered package by uri or prefix
+   *
+   * @return {Object} the package
+   */
+  Moddle.prototype.getPackage = function(uriOrPrefix) {
+    return this.registry.getPackage(uriOrPrefix);
+  };
 
   /**
-   * A utility that gets and sets properties of model elements.
+   * Returns a snapshot of all known packages
    *
-   * @param {Model} model
+   * @return {Object} the package
    */
-  function Properties(model) {
-    this.model = model;
-  }
+  Moddle.prototype.getPackages = function() {
+    return this.registry.getPackages();
+  };
 
+  /**
+   * Returns the descriptor for an element
+   */
+  Moddle.prototype.getElementDescriptor = function(element) {
+    return element.$descriptor;
+  };
 
   /**
-   * Sets a named property on the target element.
-   * If the value is undefined, the property gets deleted.
+   * Returns true if the given descriptor or instance
+   * represents the given type.
    *
-   * @param {Object} target
-   * @param {String} name
-   * @param {Object} value
+   * May be applied to this, if element is omitted.
    */
-  Properties.prototype.set = function(target, name, value) {
-
-    if (!isString(name) || !name.length) {
-      throw new TypeError('property name must be a non-empty string');
+  Moddle.prototype.hasType = function(element, type) {
+    if (type === undefined) {
+      type = element;
+      element = this;
     }
 
-    var property = this.getProperty(target, name);
-
-    var propertyName = property && property.name;
+    var descriptor = element.$model.getElementDescriptor(element);
 
-    if (isUndefined(value)) {
+    return (type in descriptor.allTypesByName);
+  };
 
-      // unset the property, if the specified value is undefined;
-      // delete from $attrs (for extensions) or the target itself
-      if (property) {
-        delete target[propertyName];
-      } else {
-        delete target.$attrs[stripGlobal(name)];
-      }
-    } else {
+  /**
+   * Returns the descriptor of an elements named property
+   */
+  Moddle.prototype.getPropertyDescriptor = function(element, property) {
+    return this.getElementDescriptor(element).propertiesByName[property];
+  };
 
-      // set the property, defining well defined properties on the fly
-      // or simply updating them in target.$attrs (for extensions)
-      if (property) {
-        if (propertyName in target) {
-          target[propertyName] = value;
-        } else {
-          defineProperty(target, property, value);
-        }
-      } else {
-        target.$attrs[stripGlobal(name)] = value;
-      }
-    }
+  /**
+   * Returns a mapped type's descriptor
+   */
+  Moddle.prototype.getTypeDescriptor = function(type) {
+    return this.registry.typeMap[type];
   };
 
   /**
-   * Returns the named property of the given element
+   * Flatten array, one level deep.
    *
-   * @param  {Object} target
-   * @param  {String} name
+   * @template T
    *
-   * @return {Object}
+   * @param {T[][] | T[] | null} [arr]
+   *
+   * @return {T[]}
    */
-  Properties.prototype.get = function(target, name) {
-
-    var property = this.getProperty(target, name);
-
-    if (!property) {
-      return target.$attrs[stripGlobal(name)];
-    }
 
-    var propertyName = property.name;
+  const nativeToString = Object.prototype.toString;
+  const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
 
-    // check if access to collection property and lazily initialize it
-    if (!target[propertyName] && property.isMany) {
-      defineProperty(target, property, []);
-    }
+  function isUndefined(obj) {
+    return obj === undefined;
+  }
 
-    return target[propertyName];
-  };
+  function isNil(obj) {
+    return obj == null;
+  }
 
+  function isArray(obj) {
+    return nativeToString.call(obj) === '[object Array]';
+  }
 
   /**
-   * Define a property on the target element
+   * @param {any} obj
    *
-   * @param  {Object} target
-   * @param  {String} name
-   * @param  {Object} options
+   * @return {boolean}
    */
-  Properties.prototype.define = function(target, name, options) {
-
-    if (!options.writable) {
-
-      var value = options.value;
-
-      // use getters for read-only variables to support ES6 proxies
-      // cf. https://github.com/bpmn-io/internal-docs/issues/386
-      options = assign$2({}, options, {
-        get: function() { return value; }
-      });
-
-      delete options.value;
-    }
+  function isFunction(obj) {
+    const tag = nativeToString.call(obj);
 
-    Object.defineProperty(target, name, options);
-  };
+    return (
+      tag === '[object Function]' ||
+      tag === '[object AsyncFunction]' ||
+      tag === '[object GeneratorFunction]' ||
+      tag === '[object AsyncGeneratorFunction]' ||
+      tag === '[object Proxy]'
+    );
+  }
 
+  function isString(obj) {
+    return nativeToString.call(obj) === '[object String]';
+  }
 
   /**
-   * Define the descriptor for an element
+   * Return true, if target owns a property with the given key.
+   *
+   * @param {Object} target
+   * @param {String} key
+   *
+   * @return {Boolean}
    */
-  Properties.prototype.defineDescriptor = function(target, descriptor) {
-    this.define(target, '$descriptor', { value: descriptor });
-  };
+  function has(target, key) {
+    return !isNil(target) && nativeHasOwnProperty.call(target, key);
+  }
 
   /**
-   * Define the model for an element
+   * @template T
+   * @typedef { (
+   *   ((e: T) => boolean) |
+   *   ((e: T, idx: number) => boolean) |
+   *   ((e: T, key: string) => boolean) |
+   *   string |
+   *   number
+   * ) } Matcher
    */
-  Properties.prototype.defineModel = function(target, model) {
-    this.define(target, '$model', { value: model });
-  };
 
   /**
-   * Return property with the given name on the element.
-   *
-   * @param {any} target
-   * @param {string} name
+   * @template T
+   * @template U
    *
-   * @return {object | null} property
+   * @typedef { (
+   *   ((e: T) => U) | string | number
+   * ) } Extractor
    */
-  Properties.prototype.getProperty = function(target, name) {
-
-    var model = this.model;
-
-    var property = model.getPropertyDescriptor(target, name);
-
-    if (property) {
-      return property;
-    }
-
-    if (name.includes(':')) {
-      return null;
-    }
-
-    const strict = model.config.strict;
-
-    if (typeof strict !== 'undefined') {
-      const error = new TypeError(`unknown property <${ name }> on <${ target.$type }>`);
 
-      if (strict) {
-        throw error;
-      } else {
 
-        // eslint-disable-next-line no-undef
-        typeof console !== 'undefined' && console.warn(error);
-      }
-    }
+  /**
+   * @template T
+   * @typedef { (val: T, key: any) => boolean } MatchFn
+   */
 
-    return null;
-  };
+  /**
+   * @template T
+   * @typedef { T[] } ArrayCollection
+   */
 
-  function isUndefined(val) {
-    return typeof val === 'undefined';
-  }
+  /**
+   * @template T
+   * @typedef { { [key: string]: T } } StringKeyValueCollection
+   */
 
-  function defineProperty(target, property, value) {
-    Object.defineProperty(target, property.name, {
-      enumerable: !property.isReference,
-      writable: true,
-      value: value,
-      configurable: true
-    });
-  }
+  /**
+   * @template T
+   * @typedef { { [key: number]: T } } NumberKeyValueCollection
+   */
 
-  function stripGlobal(name) {
-    return name.replace(/^:/, '');
-  }
+  /**
+   * @template T
+   * @typedef { StringKeyValueCollection<T> | NumberKeyValueCollection<T> } KeyValueCollection
+   */
 
-  // Moddle implementation /////////////////////////////////////////////////
+  /**
+   * @template T
+   * @typedef { KeyValueCollection<T> | ArrayCollection<T> } Collection
+   */
 
   /**
-   * @class Moddle
-   *
-   * A model that can be used to create elements of a specific type.
-   *
-   * @example
-   *
-   * var Moddle = require('moddle');
-   *
-   * var pkg = {
-   *   name: 'mypackage',
-   *   prefix: 'my',
-   *   types: [
-   *     { name: 'Root' }
-   *   ]
-   * };
-   *
-   * var moddle = new Moddle([pkg]);
+   * Find element in collection.
    *
-   * @param {Array<Package>} packages the packages to contain
+   * @template T
+   * @param {Collection<T>} collection
+   * @param {Matcher<T>} matcher
    *
-   * @param { { strict?: boolean } } [config] moddle configuration
+   * @return {Object}
    */
-  function Moddle(packages, config = {}) {
+  function find(collection, matcher) {
 
-    this.properties = new Properties(this);
+    const matchFn = toMatcher(matcher);
 
-    this.factory = new Factory(this, this.properties);
-    this.registry = new Registry(packages, this.properties);
+    let match;
 
-    this.typeCache = {};
+    forEach(collection, function(val, key) {
+      if (matchFn(val, key)) {
+        match = val;
+
+        return false;
+      }
+    });
+
+    return match;
 
-    this.config = config;
   }
 
 
   /**
-   * Create an instance of the specified type.
-   *
-   * @method Moddle#create
-   *
-   * @example
+   * Find element index in collection.
    *
-   * var foo = moddle.create('my:Foo');
-   * var bar = moddle.create('my:Bar', { id: 'BAR_1' });
+   * @template T
+   * @param {Collection<T>} collection
+   * @param {Matcher<T>} matcher
    *
-   * @param  {String|Object} descriptor the type descriptor or name know to the model
-   * @param  {Object} attrs   a number of attributes to initialize the model instance with
-   * @return {Object}         model instance
+   * @return {number | string | undefined}
    */
-  Moddle.prototype.create = function(descriptor, attrs) {
-    var Type = this.getType(descriptor);
+  function findIndex(collection, matcher) {
 
-    if (!Type) {
-      throw new Error('unknown type <' + descriptor + '>');
-    }
+    const matchFn = toMatcher(matcher);
 
-    return new Type(attrs);
-  };
+    let idx = isArray(collection) ? -1 : undefined;
+
+    forEach(collection, function(val, key) {
+      if (matchFn(val, key)) {
+        idx = key;
+
+        return false;
+      }
+    });
+
+    return idx;
+  }
 
 
   /**
-   * Returns the type representing a given descriptor
-   *
-   * @method Moddle#getType
-   *
-   * @example
+   * Filter elements in collection.
    *
-   * var Foo = moddle.getType('my:Foo');
-   * var foo = new Foo({ 'id' : 'FOO_1' });
+   * @template T
+   * @param {Collection<T>} collection
+   * @param {Matcher<T>} matcher
    *
-   * @param  {String|Object} descriptor the type descriptor or name know to the model
-   * @return {Object}         the type representing the descriptor
+   * @return {T[]} result
    */
-  Moddle.prototype.getType = function(descriptor) {
-
-    var cache = this.typeCache;
+  function filter(collection, matcher) {
 
-    var name = isString(descriptor) ? descriptor : descriptor.ns.name;
+    const matchFn = toMatcher(matcher);
 
-    var type = cache[name];
+    let result = [];
 
-    if (!type) {
-      descriptor = this.registry.getEffectiveDescriptor(name);
-      type = cache[name] = this.factory.createType(descriptor);
-    }
+    forEach(collection, function(val, key) {
+      if (matchFn(val, key)) {
+        result.push(val);
+      }
+    });
 
-    return type;
-  };
+    return result;
+  }
 
 
   /**
-   * Creates an any-element type to be used within model instances.
-   *
-   * This can be used to create custom elements that lie outside the meta-model.
-   * The created element contains all the meta-data required to serialize it
-   * as part of meta-model elements.
-   *
-   * @method Moddle#createAny
-   *
-   * @example
-   *
-   * var foo = moddle.createAny('vendor:Foo', 'http://vendor', {
-   *   value: 'bar'
-   * });
-   *
-   * var container = moddle.create('my:Container', 'http://my', {
-   *   any: [ foo ]
-   * });
-   *
-   * // go ahead and serialize the stuff
+   * Iterate over collection; returning something
+   * (non-undefined) will stop iteration.
    *
+   * @template T
+   * @param {Collection<T>} collection
+   * @param { ((item: T, idx: number) => (boolean|void)) | ((item: T, key: string) => (boolean|void)) } iterator
    *
-   * @param  {String} name  the name of the element
-   * @param  {String} nsUri the namespace uri of the element
-   * @param  {Object} [properties] a map of properties to initialize the instance with
-   * @return {Object} the any type instance
+   * @return {T} return result that stopped the iteration
    */
-  Moddle.prototype.createAny = function(name, nsUri, properties) {
-
-    var nameNs = parseName(name);
+  function forEach(collection, iterator) {
 
-    var element = {
-      $type: name,
-      $instanceOf: function(type) {
-        return type === this.$type;
-      },
-      get: function(key) {
-        return this[key];
-      },
-      set: function(key, value) {
-        set$1(this, [ key ], value);
-      }
-    };
+    let val,
+        result;
 
-    var descriptor = {
-      name: name,
-      isGeneric: true,
-      ns: {
-        prefix: nameNs.prefix,
-        localName: nameNs.localName,
-        uri: nsUri
-      }
-    };
+    if (isUndefined(collection)) {
+      return;
+    }
 
-    this.properties.defineDescriptor(element, descriptor);
-    this.properties.defineModel(element, this);
-    this.properties.define(element, 'get', { enumerable: false, writable: true });
-    this.properties.define(element, 'set', { enumerable: false, writable: true });
-    this.properties.define(element, '$parent', { enumerable: false, writable: true });
-    this.properties.define(element, '$instanceOf', { enumerable: false, writable: true });
+    const convertKey = isArray(collection) ? toNum : identity;
 
-    forEach$2(properties, function(a, key) {
-      if (isObject(a) && a.value !== undefined) {
-        element[a.name] = a.value;
-      } else {
-        element[key] = a;
-      }
-    });
+    for (let key in collection) {
 
-    return element;
-  };
+      if (has(collection, key)) {
+        val = collection[key];
 
-  /**
-   * Returns a registered package by uri or prefix
-   *
-   * @return {Object} the package
-   */
-  Moddle.prototype.getPackage = function(uriOrPrefix) {
-    return this.registry.getPackage(uriOrPrefix);
-  };
+        result = iterator(val, convertKey(key));
 
-  /**
-   * Returns a snapshot of all known packages
-   *
-   * @return {Object} the package
-   */
-  Moddle.prototype.getPackages = function() {
-    return this.registry.getPackages();
-  };
+        if (result === false) {
+          return val;
+        }
+      }
+    }
+  }
 
-  /**
-   * Returns the descriptor for an element
-   */
-  Moddle.prototype.getElementDescriptor = function(element) {
-    return element.$descriptor;
-  };
 
   /**
-   * Returns true if the given descriptor or instance
-   * represents the given type.
+   * @template T
+   * @param {Matcher<T>} matcher
    *
-   * May be applied to this, if element is omitted.
+   * @return {MatchFn<T>}
    */
-  Moddle.prototype.hasType = function(element, type) {
-    if (type === undefined) {
-      type = element;
-      element = this;
-    }
+  function toMatcher(matcher) {
+    return isFunction(matcher) ? matcher : (e) => {
+      return e === matcher;
+    };
+  }
 
-    var descriptor = element.$model.getElementDescriptor(element);
 
-    return (type in descriptor.allTypesByName);
-  };
+  function identity(arg) {
+    return arg;
+  }
 
-  /**
-   * Returns the descriptor of an elements named property
-   */
-  Moddle.prototype.getPropertyDescriptor = function(element, property) {
-    return this.getElementDescriptor(element).propertiesByName[property];
-  };
+  function toNum(arg) {
+    return Number(arg);
+  }
 
   /**
-   * Returns a mapped type's descriptor
+   * Convenience wrapper for `Object.assign`.
+   *
+   * @param {Object} target
+   * @param {...Object} others
+   *
+   * @return {Object} the target
    */
-  Moddle.prototype.getTypeDescriptor = function(type) {
-    return this.registry.typeMap[type];
-  };
+  function assign(target, ...others) {
+    return Object.assign(target, ...others);
+  }
 
   var fromCharCode = String.fromCharCode;
 
@@ -16723,7 +17335,7 @@
      * @property {Boolean} lax
      */
 
-    assign$2(this, options);
+    assign(this, options);
 
     this.elementsById = {};
     this.references = [];
@@ -16944,7 +17556,7 @@
         model = this.model,
         propNameNs;
 
-    forEach$2(attributes, function(value, name) {
+    forEach(attributes, function(value, name) {
 
       var prop = descriptor.propertiesByName[name],
           values;
@@ -16962,7 +17574,7 @@
           // IDREFS: parse references as whitespace-separated list
           values = value.split(' ');
 
-          forEach$2(values, function(v) {
+          forEach(values, function(v) {
             context.addReference({
               element: instance,
               property: prop.ns.name,
@@ -17031,7 +17643,7 @@
 
           const elementType = model.getType(normalizedTypeName);
 
-          return assign$2({}, property, {
+          return assign({}, property, {
             effectiveType: getModdleDescriptor(elementType).name
           });
         }
@@ -17053,7 +17665,7 @@
       });
 
       if (property) {
-        return assign$2({}, property, {
+        return assign({}, property, {
           effectiveType: getModdleDescriptor(elementType).name
         });
       }
@@ -17128,7 +17740,7 @@
       }
 
       if (propertyDesc.isReference) {
-        assign$2(newElement, {
+        assign(newElement, {
           element: element
         });
 
@@ -17237,7 +17849,7 @@
       };
     }
 
-    assign$2(this, { lax: false }, options);
+    assign(this, { lax: false }, options);
   }
 
   /**
@@ -17292,7 +17904,7 @@
     var model = this.model,
         lax = this.lax;
 
-    var context = new Context(assign$2({}, options, { rootHandler: rootHandler })),
+    var context = new Context(assign({}, options, { rootHandler: rootHandler })),
         parser = new Parser({ proxy: true }),
         stack = createStack();
 
@@ -17697,14 +18309,14 @@
 
   function getElementNs(ns, descriptor) {
     if (descriptor.isGeneric) {
-      return assign$2({ localName: descriptor.ns.localName }, ns);
+      return assign({ localName: descriptor.ns.localName }, ns);
     } else {
-      return assign$2({ localName: nameToAlias(descriptor.ns.localName, descriptor.$pkg) }, ns);
+      return assign({ localName: nameToAlias(descriptor.ns.localName, descriptor.$pkg) }, ns);
     }
   }
 
   function getPropertyNs(ns, descriptor) {
-    return assign$2({ localName: descriptor.ns.localName }, ns);
+    return assign({ localName: descriptor.ns.localName }, ns);
   }
 
   function getSerializableProperties(element) {
@@ -17718,7 +18330,7 @@
       }
 
       // do not serialize defaults
-      if (!has$2(element, name)) {
+      if (!has(element, name)) {
         return false;
       }
 
@@ -17938,7 +18550,7 @@
     if (this.isLocalNs(effectiveNs)) {
       return { localName: ns.localName };
     } else {
-      return assign$2({ localName: ns.localName }, effectiveNs);
+      return assign({ localName: ns.localName }, effectiveNs);
     }
   };
 
@@ -17961,7 +18573,7 @@
     var children = element.$children;
 
     if (children) {
-      forEach$2(children, child => {
+      forEach(children, child => {
         this.body.push(new ElementSerializer(this).build(child));
       });
     }
@@ -18021,7 +18633,7 @@
     // parse namespace attributes first
     // and log them. push non namespace attributes to a list
     // and process them later
-    forEach$2(genericAttrs, function(value, name) {
+    forEach(genericAttrs, function(value, name) {
 
       var nonNsAttr = self.parseNsAttribute(element, name, value);
 
@@ -18037,7 +18649,7 @@
 
     var self = this;
 
-    forEach$2(attributes, function(attr) {
+    forEach(attributes, function(attr) {
 
       try {
         self.addAttribute(self.nsAttributeName(attr.name), attr.value);
@@ -18059,7 +18671,7 @@
         body = this.body,
         element = this.element;
 
-    forEach$2(properties, function(p) {
+    forEach(properties, function(p) {
       var value = element.get(p.name),
           isReference = p.isReference,
           isMany = p.isMany;
@@ -18071,11 +18683,11 @@
       if (p.isBody) {
         body.push(new BodySerializer().build(p, value[0]));
       } else if (isSimple(p.type)) {
-        forEach$2(value, function(v) {
+        forEach(value, function(v) {
           body.push(new ValueSerializer(self.addTagName(self.nsPropertyTagName(p))).build(p, v));
         });
       } else if (isReference) {
-        forEach$2(value, function(v) {
+        forEach(value, function(v) {
           body.push(new ReferenceSerializer(self.addTagName(self.nsPropertyTagName(p))).build(v));
         });
       } else {
@@ -18084,7 +18696,7 @@
         // rather than element name
         var serialization = getSerialization(p);
 
-        forEach$2(value, function(v) {
+        forEach(value, function(v) {
           var serializer;
 
           if (serialization) {
@@ -18196,7 +18808,7 @@
     var self = this,
         element = this.element;
 
-    forEach$2(properties, function(p) {
+    forEach(properties, function(p) {
 
       var value = element.get(p.name);
 
@@ -18206,7 +18818,7 @@
           value = value.id;
         } else {
           var values = [];
-          forEach$2(value, function(v) {
+          forEach(value, function(v) {
             values.push(v.id);
           });
 
@@ -18262,7 +18874,7 @@
       attrs = getNsAttrs(namespaces).concat(attrs);
     }
 
-    forEach$2(attrs, function(a) {
+    forEach(attrs, function(a) {
       writer
         .append(' ')
         .append(nsName(a.name)).append('="').append(a.value).append('"');
@@ -18289,7 +18901,7 @@
           .indent();
       }
 
-      forEach$2(this.body, function(b) {
+      forEach(this.body, function(b) {
         b.serializeTo(writer);
       });
 
@@ -18404,7 +19016,7 @@
    */
   function Writer(options) {
 
-    options = assign$2({ format: false, preamble: true }, options || {});
+    options = assign({ format: false, preamble: true }, options || {});
 
     function toXML(tree, writer) {
       var internalWriter = writer || new SavingWriter();
@@ -18510,7 +19122,7 @@
    */
   BpmnModdle.prototype.fromXML = function(xmlStr, typeName, options) {
 
-    if (!isString(typeName)) {
+    if (!isString$2(typeName)) {
       options = typeName;
       typeName = 'bpmn:Definitions';
     }
@@ -22222,7 +22834,7 @@
   function ensureCompatDiRef(businessObject) {
 
     // bpmnElement can have multiple independent DIs
-    if (!has$2(businessObject, 'di')) {
+    if (!has$5(businessObject, 'di')) {
       Object.defineProperty(businessObject, 'di', {
         enumerable: false,
         get: function() {
@@ -22258,7 +22870,7 @@
    * @return {ModdleElement}
    */
   function findDisplayCandidate(definitions) {
-    return find(definitions.rootElements, function(e) {
+    return find$2(definitions.rootElements, function(e) {
       return is(e, 'bpmn:Process') || is(e, 'bpmn:Collaboration');
     });
   }
@@ -22362,7 +22974,7 @@
     function handlePlane(plane) {
       registerDi(plane);
 
-      forEach$2(plane.planeElement, handlePlaneElement);
+      forEach$5(plane.planeElement, handlePlaneElement);
     }
 
     function handlePlaneElement(planeElement) {
@@ -22480,7 +23092,7 @@
       // walk through all processes that have not yet been drawn and draw them
       // if they contain lanes with DI information.
       // we do this to pass the free-floating lane test cases in the MIWG test suite
-      var processes = filter(rootElements, function(e) {
+      var processes = filter$2(rootElements, function(e) {
         return !isHandled(e) && is(e, 'bpmn:Process') && e.laneSets;
       });
 
@@ -22492,7 +23104,7 @@
     }
 
     function handleMessageFlows(messageFlows, context) {
-      forEach$2(messageFlows, contextual(handleMessageFlow, context));
+      forEach$5(messageFlows, contextual(handleMessageFlow, context));
     }
 
     function handleDataAssociation(association, context) {
@@ -22518,7 +23130,7 @@
 
     function handleArtifacts(artifacts, context) {
 
-      forEach$2(artifacts, function(e) {
+      forEach$5(artifacts, function(e) {
         if (is(e, 'bpmn:Association')) {
           deferred.push(function() {
             handleArtifact(e, context);
@@ -22535,8 +23147,8 @@
         return;
       }
 
-      forEach$2(ioSpecification.dataInputs, contextual(handleDataInput, context));
-      forEach$2(ioSpecification.dataOutputs, contextual(handleDataOutput, context));
+      forEach$5(ioSpecification.dataInputs, contextual(handleDataInput, context));
+      forEach$5(ioSpecification.dataOutputs, contextual(handleDataOutput, context));
     }
 
     var handleSubProcess = this.handleSubProcess = function handleSubProcess(subProcess, context) {
@@ -22563,8 +23175,8 @@
       //   * bpmn:CatchEvent
       //
       deferred.push(function() {
-        forEach$2(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));
-        forEach$2(flowNode.dataOutputAssociations, contextual(handleDataAssociation, context));
+        forEach$5(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));
+        forEach$5(flowNode.dataOutputAssociations, contextual(handleDataAssociation, context));
       });
     }
 
@@ -22591,11 +23203,11 @@
     }
 
     function handleLaneSet(laneSet, context) {
-      forEach$2(laneSet.lanes, contextual(handleLane, context));
+      forEach$5(laneSet.lanes, contextual(handleLane, context));
     }
 
     function handleLaneSets(laneSets, context) {
-      forEach$2(laneSets, contextual(handleLaneSet, context));
+      forEach$5(laneSets, contextual(handleLaneSet, context));
     }
 
     function handleFlowElementsContainer(container, context) {
@@ -22607,7 +23219,7 @@
     }
 
     function handleFlowElements(flowElements, context) {
-      forEach$2(flowElements, function(flowElement) {
+      forEach$5(flowElements, function(flowElement) {
         if (is(flowElement, 'bpmn:SequenceFlow')) {
           deferred.push(function() {
             handleSequenceFlow(flowElement, context);
@@ -22645,7 +23257,7 @@
 
     function handleCollaboration(collaboration, context) {
 
-      forEach$2(collaboration.participants, contextual(handleParticipant, context));
+      forEach$5(collaboration.participants, contextual(handleParticipant, context));
 
       deferred.push(function() {
         handleMessageFlows(collaboration.messageFlows, context);
@@ -22658,7 +23270,7 @@
     function wireFlowNodeRefs(lane) {
 
       // wire the virtual flowNodeRefs <-> relationship
-      forEach$2(lane.flowNodeRef, function(flowNode) {
+      forEach$5(lane.flowNodeRef, function(flowNode) {
         var lanes = flowNode.get('lanes');
 
         if (lanes) {
@@ -22736,7 +23348,7 @@
 
       // traverse BPMN 2.0 document model,
       // starting at definitions
-      forEach$2(diagramsToImport, function(diagram) {
+      forEach$5(diagramsToImport, function(diagram) {
         walker.handleDefinitions(definitions, diagram);
       });
 
@@ -22802,12 +23414,12 @@
     if (is$1(rootElement, 'bpmn:Collaboration')) {
       collaboration = rootElement;
     } else {
-      collaboration = find(definitions.rootElements, function(element) {
+      collaboration = find$2(definitions.rootElements, function(element) {
         if (!is$1(element, 'bpmn:Collaboration')) {
           return;
         }
 
-        return find(element.participants, function(participant) {
+        return find$2(element.participants, function(participant) {
           return participant.processRef === rootElement;
         });
       });
@@ -22831,7 +23443,7 @@
     var diagramsToImport = [ bpmnDiagram ];
     var handledElements = [ bpmnElement ];
 
-    forEach$2(definitions.diagrams, function(diagram) {
+    forEach$5(definitions.diagrams, function(diagram) {
 
       if (!diagram.plane) {
         return;
@@ -22855,7 +23467,7 @@
   function selfAndAllFlowElements(elements) {
     var result = [];
 
-    forEach$2(elements, function(element) {
+    forEach$5(elements, function(element) {
       if (!element) {
         return;
       }
@@ -22951,11 +23563,11 @@
   function createLightbox() {
     lightbox = domify$1$1(LIGHTBOX_MARKUP);
 
-    assign$1(lightbox, LIGHTBOX_STYLES);
-    assign$1(query$1('svg', lightbox), LOGO_STYLES);
-    assign$1(query$1('.backdrop', lightbox), BACKDROP_STYLES);
-    assign$1(query$1('.notice', lightbox), NOTICE_STYLES);
-    assign$1(query$1('.link', lightbox), LINK_STYLES, {
+    assign$4(lightbox, LIGHTBOX_STYLES);
+    assign$4(query$1('svg', lightbox), LOGO_STYLES);
+    assign$4(query$1('.backdrop', lightbox), BACKDROP_STYLES);
+    assign$4(query$1('.notice', lightbox), NOTICE_STYLES);
+    assign$4(query$1('.link', lightbox), LINK_STYLES, {
       'margin': '15px 20px 15px 10px',
       'alignSelf': 'center'
     });
@@ -23095,7 +23707,7 @@
     /**
      * @type {BaseViewerOptions}
      */
-    options = assign$2({}, DEFAULT_OPTIONS, options);
+    options = assign$6({}, DEFAULT_OPTIONS, options);
 
     /**
      * @type {Moddle}
@@ -23639,8 +24251,8 @@
 
     const diagramModules = [].concat(staticModules, baseModules, additionalModules);
 
-    const diagramOptions = assign$2(omit(options, [ 'additionalModules' ]), {
-      canvas: assign$2({}, options.canvas, { container: container }),
+    const diagramOptions = assign$6(omit(options, [ 'additionalModules' ]), {
+      canvas: assign$6({}, options.canvas, { container: container }),
       modules: diagramModules
     });
 
@@ -23673,7 +24285,7 @@
 
     const container = domify$1$1('<div class="bjs-container"></div>');
 
-    assign$1(container, {
+    assign$4(container, {
       width: ensureUnit(options.width),
       height: ensureUnit(options.height),
       position: options.position
@@ -23688,7 +24300,7 @@
    * @return {Moddle}
    */
   BaseViewer.prototype._createModdle = function(options) {
-    const moddleOptions = assign$2({}, this._moddleExtensions, options.moddleExtensions);
+    const moddleOptions = assign$6({}, this._moddleExtensions, options.moddleExtensions);
 
     return new SimpleBpmnModdle(moddleOptions);
   };
@@ -23730,7 +24342,7 @@
    * Ensure the passed argument is a proper unit (defaulting to px)
    */
   function ensureUnit(val) {
-    return val + (isNumber(val) ? 'px' : '');
+    return val + (isNumber$1(val) ? 'px' : '');
   }
 
 
@@ -23747,7 +24359,7 @@
       return null;
     }
 
-    return find(definitions.diagrams, function(element) {
+    return find$2(definitions.diagrams, function(element) {
       return element.id === diagramId;
     }) || null;
   }
@@ -23774,8 +24386,8 @@
 
     const linkElement = domify$1$1(linkMarkup);
 
-    assign$1(query$1('svg', linkElement), LOGO_STYLES);
-    assign$1(linkElement, LINK_STYLES, {
+    assign$4(query$1('svg', linkElement), LOGO_STYLES);
+    assign$4(linkElement, LINK_STYLES, {
       position: 'absolute',
       bottom: '15px',
       right: '15px',
@@ -23862,6 +24474,7 @@
 
   var KEYS_COPY = [ 'c', 'C' ];
   var KEYS_PASTE = [ 'v', 'V' ];
+  var KEYS_DUPLICATE = [ 'd', 'D' ];
   var KEYS_REDO = [ 'y', 'Y' ];
   var KEYS_UNDO = [ 'z', 'Z' ];
 
@@ -23896,7 +24509,7 @@
    * @return {boolean}
    */
   function isKey(keys, event) {
-    keys = isArray$3(keys) ? keys : [ keys ];
+    keys = isArray$5(keys) ? keys : [ keys ];
 
     return keys.indexOf(event.key) !== -1 || keys.indexOf(event.code) !== -1;
   }
@@ -23922,6 +24535,13 @@
     return isCmd(event) && isKey(KEYS_PASTE, event);
   }
 
+  /**
+   * @param {KeyboardEvent} event
+   */
+  function isDuplicate(event) {
+    return isCmd(event) && isKey(KEYS_DUPLICATE, event);
+  }
+
   /**
    * @param {KeyboardEvent} event
    */
@@ -24117,7 +24737,7 @@
    * @param {string} [type='keyboard.keydown']
    */
   Keyboard.prototype.addListener = function(priority, listener, type) {
-    if (isFunction(priority)) {
+    if (isFunction$1(priority)) {
       type = listener;
       listener = priority;
       priority = DEFAULT_PRIORITY;
@@ -24247,6 +24867,20 @@
       }
     });
 
+    // duplicate
+    // CTRL/CMD + D
+    addListener('duplicate', function(context) {
+
+      var event = context.keyEvent;
+
+      if (isDuplicate(event)) {
+        editorActions.trigger('duplicate');
+
+        return true;
+      }
+    });
+
+
     // zoom in one step
     // CTRL/CMD + +
     addListener('stepZoom', function(context) {
@@ -24339,7 +24973,7 @@
 
     var self = this;
 
-    this._config = assign$2({}, DEFAULT_CONFIG, config || {});
+    this._config = assign$5({}, DEFAULT_CONFIG, config || {});
 
     keyboard.addListener(arrowsListener);
 
@@ -24729,7 +25363,7 @@
     this._canvas = canvas;
     this._container = canvas._container;
 
-    this._handleWheel = bind$3(this._handleWheel, this);
+    this._handleWheel = bind$4(this._handleWheel, this);
 
     this._totalDelta = 0;
     this._scale = config.scale || DEFAULT_SCALE;
@@ -24958,6 +25592,16 @@
     NavigatedViewer.prototype._navigationModules
   );
 
+  /**
+   * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+   * under one or more contributor license agreements. See the NOTICE file
+   * distributed with this work for additional information regarding copyright
+   * ownership.
+   *
+   * Camunda licenses this file to you under the MIT; you may not use this file
+   * except in compliance with the MIT License.
+   */
+
   return NavigatedViewer;
 
 }));