UNPKG

bpmn-js/dist/bpmn-modeler.development.js

Version:
1.45 MBJavaScriptView Raw
1/*!
* bpmn-js - bpmn-modeler v9.1.0
*
* Copyright (c) 2014-present, camunda Services GmbH
*
* Released under the bpmn.io license
* http://bpmn.io/license
*
* Source Code: https://github.com/bpmn-io/bpmn-js
*
* Date: 2022-05-18
*/
13(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.BpmnJS = factory());
17}(this, (function () { 'use strict';
18
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
20
var inherits_browser = {exports: {}};
22
if (typeof Object.create === 'function') {
 // implementation from standard node.js 'util' module
 inherits_browser.exports = function inherits(ctor, superCtor) {
   if (superCtor) {
     ctor.super_ = superCtor;
     ctor.prototype = Object.create(superCtor.prototype, {
       constructor: {
         value: ctor,
         enumerable: false,
         writable: true,
         configurable: true
       }
     });
   }
 };
} else {
 // old school shim for old browsers
 inherits_browser.exports = function inherits(ctor, superCtor) {
   if (superCtor) {
     ctor.super_ = superCtor;
     var TempCtor = function () {};
     TempCtor.prototype = superCtor.prototype;
     ctor.prototype = new TempCtor();
     ctor.prototype.constructor = ctor;
   }
 };
}
50
var inherits$1 = inherits_browser.exports;
52
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
56
var hat_1 = createCommonjsModule(function (module) {
var hat = module.exports = function (bits, base) {
   if (!base) base = 16;
   if (bits === undefined) bits = 128;
   if (bits <= 0) return '0';
   
   var digits = Math.log(Math.pow(2, bits)) / Math.log(base);
   for (var i = 2; digits === Infinity; i *= 2) {
       digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;
   }
   
   var rem = digits - Math.floor(digits);
   
   var res = '';
   
   for (var i = 0; i < Math.floor(digits); i++) {
       var x = Math.floor(Math.random() * base).toString(base);
       res = x + res;
   }
   
   if (rem) {
       var b = Math.pow(base, rem);
       var x = Math.floor(Math.random() * b).toString(base);
       res = x + res;
   }
   
   var parsed = parseInt(res, base);
   if (parsed !== Infinity && parsed >= Math.pow(2, bits)) {
       return hat(bits, base)
   }
   else return res;
};
89
hat.rack = function (bits, base, expandBy) {
   var fn = function (data) {
       var iters = 0;
       do {
           if (iters ++ > 10) {
               if (expandBy) bits += expandBy;
               else throw new Error('too many ID collisions, use more bits')
           }
           
           var id = hat(bits, base);
       } while (Object.hasOwnProperty.call(hats, id));
       
       hats[id] = data;
       return id;
   };
   var hats = fn.hats = {};
   
   fn.get = function (id) {
       return fn.hats[id];
   };
   
   fn.set = function (id, value) {
       fn.hats[id] = value;
       return fn;
   };
   
   fn.bits = bits || 128;
   fn.base = base || 16;
   return fn;
};
});
121
/**
* Create a new id generator / cache instance.
*
* You may optionally provide a seed that is used internally.
*
* @param {Seed} seed
*/
129
function Ids(seed) {
 if (!(this instanceof Ids)) {
   return new Ids(seed);
 }
134
 seed = seed || [128, 36, 1];
 this._seed = seed.length ? hat_1.rack(seed[0], seed[1], seed[2]) : seed;
}
/**
* Generate a next id.
*
* @param {Object} [element] element to bind the id to
*
* @return {String} id
*/
145
Ids.prototype.next = function (element) {
 return this._seed(element || true);
};
/**
* Generate a next id with a given prefix.
*
* @param {Object} [element] element to bind the id to
*
* @return {String} id
*/
156
157
Ids.prototype.nextPrefixed = function (prefix, element) {
 var id;
160
 do {
   id = prefix + this.next(true);
 } while (this.assigned(id)); // claim {prefix}{random}
164
165
 this.claim(id, element); // return
167
 return id;
};
/**
* Manually claim an existing id.
*
* @param {String} id
* @param {String} [element] element the id is claimed by
*/
176
177
Ids.prototype.claim = function (id, element) {
 this._seed.set(id, element || true);
};
/**
* Returns true if the given id has already been assigned.
*
* @param  {String} id
* @return {Boolean}
*/
187
188
Ids.prototype.assigned = function (id) {
 return this._seed.get(id) || false;
};
/**
* Unclaim an id.
*
* @param  {String} id the id to unclaim
*/
197
198
Ids.prototype.unclaim = function (id) {
 delete this._seed.hats[id];
};
/**
* Clear all claimed ids.
*/
205
206
Ids.prototype.clear = function () {
 var hats = this._seed.hats,
     id;
210
 for (id in hats) {
   this.unclaim(id);
 }
};
215
/**
* Flatten array, one level deep.
*
* @param {Array<?>} arr
*
* @return {Array<?>}
*/
function flatten(arr) {
 return Array.prototype.concat.apply([], arr);
}
226
var nativeToString$2 = Object.prototype.toString;
var nativeHasOwnProperty$2 = Object.prototype.hasOwnProperty;
function isUndefined$3(obj) {
 return obj === undefined;
}
function isDefined(obj) {
 return obj !== undefined;
}
function isNil(obj) {
 return obj == null;
}
function isArray$4(obj) {
 return nativeToString$2.call(obj) === '[object Array]';
}
function isObject(obj) {
 return nativeToString$2.call(obj) === '[object Object]';
}
function isNumber(obj) {
 return nativeToString$2.call(obj) === '[object Number]';
}
function isFunction(obj) {
 var tag = nativeToString$2.call(obj);
 return tag === '[object Function]' || tag === '[object AsyncFunction]' || tag === '[object GeneratorFunction]' || tag === '[object AsyncGeneratorFunction]' || tag === '[object Proxy]';
}
function isString(obj) {
 return nativeToString$2.call(obj) === '[object String]';
}
/**
* Ensure collection is an array.
*
* @param {Object} obj
*/
259
function ensureArray(obj) {
 if (isArray$4(obj)) {
   return;
 }
264
 throw new Error('must supply array');
}
/**
* Return true, if target owns a property with the given key.
*
* @param {Object} target
* @param {String} key
*
* @return {Boolean}
*/
275
function has$2(target, key) {
 return nativeHasOwnProperty$2.call(target, key);
}
279
/**
* Find element in collection.
*
* @param  {Array|Object} collection
* @param  {Function|Object} matcher
*
* @return {Object}
*/
288
function find(collection, matcher) {
 matcher = toMatcher(matcher);
 var match;
 forEach$2(collection, function (val, key) {
   if (matcher(val, key)) {
     match = val;
     return false;
   }
 });
 return match;
}
/**
* Find element index in collection.
*
* @param  {Array|Object} collection
* @param  {Function} matcher
*
* @return {Object}
*/
308
function findIndex(collection, matcher) {
 matcher = toMatcher(matcher);
 var idx = isArray$4(collection) ? -1 : undefined;
 forEach$2(collection, function (val, key) {
   if (matcher(val, key)) {
     idx = key;
     return false;
   }
 });
 return idx;
}
/**
* Find element in collection.
*
* @param  {Array|Object} collection
* @param  {Function} matcher
*
* @return {Array} result
*/
328
function filter(collection, matcher) {
 var result = [];
 forEach$2(collection, function (val, key) {
   if (matcher(val, key)) {
     result.push(val);
   }
 });
 return result;
}
/**
* Iterate over collection; returning something
* (non-undefined) will stop iteration.
*
* @param  {Array|Object} collection
* @param  {Function} iterator
*
* @return {Object} return result that stopped the iteration
*/
347
function forEach$2(collection, iterator) {
 var val, result;
350
 if (isUndefined$3(collection)) {
   return;
 }
354
 var convertKey = isArray$4(collection) ? toNum$2 : identity$2;
356
 for (var key in collection) {
   if (has$2(collection, key)) {
     val = collection[key];
     result = iterator(val, convertKey(key));
361
     if (result === false) {
       return val;
     }
   }
 }
}
/**
* Return collection without element.
*
* @param  {Array} arr
* @param  {Function} matcher
*
* @return {Array}
*/
376
function without(arr, matcher) {
 if (isUndefined$3(arr)) {
   return [];
 }
381
 ensureArray(arr);
 matcher = toMatcher(matcher);
 return arr.filter(function (el, idx) {
   return !matcher(el, idx);
 });
}
/**
* Reduce collection, returning a single result.
*
* @param  {Object|Array} collection
* @param  {Function} iterator
* @param  {Any} result
*
* @return {Any} result returned from last iterator
*/
397
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}
*/
413
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.
*
* @param  {Object|Array} collection
* @param  {Function} matcher
*
* @return {Boolean}
*/
428
function some(collection, matcher) {
 return !!find(collection, matcher);
}
/**
* Transform a collection into another collection
* by piping each member through the given fn.
*
* @param  {Object|Array}   collection
* @param  {Function} fn
*
* @return {Array} transformed collection
*/
441
function map(collection, fn) {
 var result = [];
 forEach$2(collection, function (val, key) {
   result.push(fn(val, key));
 });
 return result;
}
/**
* Get the collections keys.
*
* @param  {Object|Array} collection
*
* @return {Array}
*/
456
function keys(collection) {
 return collection && Object.keys(collection) || [];
}
/**
* Shorthand for `keys(o).length`.
*
* @param  {Object|Array} collection
*
* @return {Number}
*/
467
function size(collection) {
 return keys(collection).length;
}
/**
* Get the values in the collection.
*
* @param  {Object|Array} collection
*
* @return {Array}
*/
478
function values(collection) {
 return map(collection, function (val) {
   return val;
 });
}
/**
* Group collection members by attribute.
*
* @param  {Object|Array} collection
* @param  {Function} extractor
*
* @return {Object} map with { attrValue => [ a, b, c ] }
*/
492
function groupBy(collection, extractor) {
 var grouped = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 extractor = toExtractor(extractor);
 forEach$2(collection, function (val) {
   var discriminator = extractor(val) || '_';
   var group = grouped[discriminator];
499
   if (!group) {
     group = grouped[discriminator] = [];
   }
503
   group.push(val);
 });
 return grouped;
}
function uniqueBy(extractor) {
 extractor = toExtractor(extractor);
 var grouped = {};
511
 for (var _len = arguments.length, collections = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
   collections[_key - 1] = arguments[_key];
 }
515
 forEach$2(collections, function (c) {
   return groupBy(c, extractor, grouped);
 });
 var result = map(grouped, function (val, key) {
   return val[0];
 });
 return result;
}
var unionBy = uniqueBy;
/**
* Sort collection by criteria.
*
* @param  {Object|Array} collection
* @param  {String|Function} extractor
*
* @return {Array}
*/
533
function sortBy(collection, extractor) {
 extractor = toExtractor(extractor);
 var sorted = [];
 forEach$2(collection, function (value, key) {
   var disc = extractor(value, key);
   var entry = {
     d: disc,
     v: value
   };
543
   for (var idx = 0; idx < sorted.length; idx++) {
     var d = sorted[idx].d;
546
     if (disc < d) {
       sorted.splice(idx, 0, entry);
       return;
     }
   } // not inserted, append (!)
552
553
   sorted.push(entry);
 });
 return map(sorted, function (e) {
   return e.v;
 });
}
/**
* Create an object pattern matcher.
*
* @example
*
* const matcher = matchPattern({ id: 1 });
*
* let element = find(elements, matcher);
*
* @param  {Object} pattern
*
* @return {Function} matcherFn
*/
573
function matchPattern(pattern) {
 return function (el) {
   return every(pattern, function (val, key) {
     return el[key] === val;
   });
 };
}
581
function toExtractor(extractor) {
 return isFunction(extractor) ? extractor : function (e) {
   return e[extractor];
 };
}
587
function toMatcher(matcher) {
 return isFunction(matcher) ? matcher : function (e) {
   return e === matcher;
 };
}
593
function identity$2(arg) {
 return arg;
}
597
function toNum$2(arg) {
 return Number(arg);
}
601
/**
* 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 {Function} debounced function
*/
function debounce(fn, timeout) {
 var timer;
 var lastArgs;
 var lastThis;
 var lastNow;
619
 function fire(force) {
   var now = Date.now();
   var scheduledDiff = force ? 0 : lastNow + timeout - now;
623
   if (scheduledDiff > 0) {
     return schedule(scheduledDiff);
   }
627
   fn.apply(lastThis, lastArgs);
   clear();
 }
631
 function schedule(timeout) {
   timer = setTimeout(fire, timeout);
 }
635
 function clear() {
   if (timer) {
     clearTimeout(timer);
   }
640
   timer = lastNow = lastArgs = lastThis = undefined;
 }
643
 function flush() {
   if (timer) {
     fire(true);
   }
648
   clear();
 }
651
 function callback() {
   lastNow = Date.now();
654
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
   }
658
   lastArgs = args;
   lastThis = this; // ensure an execution is scheduled
661
   if (!timer) {
     schedule(timeout);
   }
 }
666
 callback.flush = flush;
 callback.cancel = clear;
 return callback;
}
/**
* Bind function against target <this>.
*
* @param  {Function} fn
* @param  {Object}   target
*
* @return {Function} bound function
*/
679
function bind(fn, target) {
 return fn.bind(target);
}
683
function _extends() {
 _extends = Object.assign || function (target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i];
688
     for (var key in source) {
       if (Object.prototype.hasOwnProperty.call(source, key)) {
         target[key] = source[key];
       }
     }
   }
695
   return target;
 };
698
 return _extends.apply(this, arguments);
}
701
/**
* Convenience wrapper for `Object.assign`.
*
* @param {Object} target
* @param {...Object} others
*
* @return {Object} the target
*/
710
function assign(target) {
 for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
   others[_key - 1] = arguments[_key];
 }
715
 return _extends.apply(void 0, [target].concat(others));
}
/**
* Pick given properties from the target object.
*
* @param {Object} target
* @param {Array} properties
*
* @return {Object} target
*/
726
function pick(target, properties) {
 var result = {};
 var 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.
*
* @param {Object} target
* @param {Array} properties
*
* @return {Object} target
*/
745
function omit(target, properties) {
 var result = {};
 var obj = Object(target);
 forEach$2(obj, function (prop, key) {
   if (properties.indexOf(key) === -1) {
     result[key] = prop;
   }
 });
 return result;
}
756
/**
* Flatten array, one level deep.
*
* @param {Array<?>} arr
*
* @return {Array<?>}
*/
764
var nativeToString$1 = Object.prototype.toString;
var nativeHasOwnProperty$1 = Object.prototype.hasOwnProperty;
function isUndefined$2(obj) {
 return obj === undefined;
}
function isArray$3(obj) {
 return nativeToString$1.call(obj) === '[object Array]';
}
/**
* Return true, if target owns a property with the given key.
*
* @param {Object} target
* @param {String} key
*
* @return {Boolean}
*/
781
function has$1(target, key) {
 return nativeHasOwnProperty$1.call(target, key);
}
/**
* Iterate over collection; returning something
* (non-undefined) will stop iteration.
*
* @param  {Array|Object} collection
* @param  {Function} iterator
*
* @return {Object} return result that stopped the iteration
*/
794
function forEach$1(collection, iterator) {
 var val, result;
797
 if (isUndefined$2(collection)) {
   return;
 }
801
 var convertKey = isArray$3(collection) ? toNum$1 : identity$1;
803
 for (var key in collection) {
   if (has$1(collection, key)) {
     val = collection[key];
     result = iterator(val, convertKey(key));
808
     if (result === false) {
       return val;
     }
   }
 }
}
815
function identity$1(arg) {
 return arg;
}
819
function toNum$1(arg) {
 return Number(arg);
}
823
/**
* Assigns style attributes in a style-src compliant way.
*
* @param {Element} element
* @param {...Object} styleSources
*
* @return {Element} the element
*/
function assign$1$1(element) {
 var target = element.style;
834
 for (var _len = arguments.length, styleSources = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
   styleSources[_key - 1] = arguments[_key];
 }
838
 forEach$1(styleSources, function (style) {
   if (!style) {
     return;
   }
843
   forEach$1(style, function (value, key) {
     target[key] = value;
   });
 });
848
 return element;
}
851
var indexOf$2 = [].indexOf;
853
var indexof$1 = function(arr, obj){
 if (indexOf$2) return arr.indexOf(obj);
 for (var i = 0; i < arr.length; ++i) {
   if (arr[i] === obj) return i;
 }
 return -1;
};
861
/**
* Taken from https://github.com/component/classes
*
* Without the component bits.
*/
867
/**
* Whitespace regexp.
*/
871
var re$2 = /\s+/;
873
/**
* toString reference.
*/
877
var toString$2 = Object.prototype.toString;
879
/**
* Wrap `el` in a `ClassList`.
*
* @param {Element} el
* @return {ClassList}
* @api public
*/
887
function classes$2(el) {
 return new ClassList$2(el);
}
891
/**
* Initialize a new ClassList for `el`.
*
* @param {Element} el
* @api private
*/
898
function ClassList$2(el) {
 if (!el || !el.nodeType) {
   throw new Error('A DOM element reference is required');
 }
 this.el = el;
 this.list = el.classList;
}
906
/**
* Add class `name` if not already present.
*
* @param {String} name
* @return {ClassList}
* @api public
*/
914
ClassList$2.prototype.add = function (name) {
 // classList
 if (this.list) {
   this.list.add(name);
   return this;
 }
921
 // fallback
 var arr = this.array();
 var i = indexof$1(arr, name);
 if (!~i) arr.push(name);
 this.el.className = arr.join(' ');
 return this;
};
929
/**
* Remove class `name` when present, or
* pass a regular expression to remove
* any which match.
*
* @param {String|RegExp} name
* @return {ClassList}
* @api public
*/
939
ClassList$2.prototype.remove = function (name) {
 if ('[object RegExp]' == toString$2.call(name)) {
   return this.removeMatching(name);
 }
944
 // classList
 if (this.list) {
   this.list.remove(name);
   return this;
 }
950
 // fallback
 var arr = this.array();
 var i = indexof$1(arr, name);
 if (~i) arr.splice(i, 1);
 this.el.className = arr.join(' ');
 return this;
};
958
/**
* Remove all classes matching `re`.
*
* @param {RegExp} re
* @return {ClassList}
* @api private
*/
966
ClassList$2.prototype.removeMatching = function (re) {
 var arr = this.array();
 for (var i = 0; i < arr.length; i++) {
   if (re.test(arr[i])) {
     this.remove(arr[i]);
   }
 }
 return this;
};
976
/**
* Toggle class `name`, can force state via `force`.
*
* For browsers that support classList, but do not support `force` yet,
* the mistake will be detected and corrected.
*
* @param {String} name
* @param {Boolean} force
* @return {ClassList}
* @api public
*/
988
ClassList$2.prototype.toggle = function (name, force) {
 // classList
 if (this.list) {
   if ('undefined' !== typeof force) {
     if (force !== this.list.toggle(name, force)) {
       this.list.toggle(name); // toggle again to correct
     }
   } else {
     this.list.toggle(name);
   }
   return this;
 }
1001
 // fallback
 if ('undefined' !== typeof force) {
   if (!force) {
     this.remove(name);
   } else {
     this.add(name);
   }
 } else {
   if (this.has(name)) {
     this.remove(name);
   } else {
     this.add(name);
   }
 }
1016
 return this;
};
1019
/**
* Return an array of classes.
*
* @return {Array}
* @api public
*/
1026
ClassList$2.prototype.array = function () {
 var className = this.el.getAttribute('class') || '';
 var str = className.replace(/^\s+|\s+$/g, '');
 var arr = str.split(re$2);
 if ('' === arr[0]) arr.shift();
 return arr;
};
1034
/**
* Check if class `name` is present.
*
* @param {String} name
* @return {ClassList}
* @api public
*/
1042
ClassList$2.prototype.has = ClassList$2.prototype.contains = function (name) {
 return this.list ? this.list.contains(name) : !!~indexof$1(this.array(), name);
};
1046
var proto$1 = typeof Element !== 'undefined' ? Element.prototype : {};
var vendor$1 = proto$1.matches
 || proto$1.matchesSelector
 || proto$1.webkitMatchesSelector
 || proto$1.mozMatchesSelector
 || proto$1.msMatchesSelector
 || proto$1.oMatchesSelector;
1054
var matchesSelector$1 = match$1;
1056
/**
* Match `el` to `selector`.
*
* @param {Element} el
* @param {String} selector
* @return {Boolean}
* @api public
*/
1065
function match$1(el, selector) {
 if (!el || el.nodeType !== 1) return false;
 if (vendor$1) return vendor$1.call(el, selector);
 var nodes = el.parentNode.querySelectorAll(selector);
 for (var i = 0; i < nodes.length; i++) {
   if (nodes[i] == el) return true;
 }
 return false;
}
1075
/**
* Closest
*
* @param {Element} el
* @param {String} selector
* @param {Boolean} checkYourSelf (optional)
*/
function closest$1 (element, selector, checkYourSelf) {
 var currentElem = checkYourSelf ? element : element.parentNode;
1085
 while (currentElem && currentElem.nodeType !== document.DOCUMENT_NODE && currentElem.nodeType !== document.DOCUMENT_FRAGMENT_NODE) {
1087
   if (matchesSelector$1(currentElem, selector)) {
     return currentElem;
   }
1091
   currentElem = currentElem.parentNode;
 }
1094
 return matchesSelector$1(currentElem, selector) ? currentElem : null;
}
1097
var bind$1$1 = window.addEventListener ? 'addEventListener' : 'attachEvent',
   unbind$2 = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
   prefix$7 = bind$1$1 !== 'addEventListener' ? 'on' : '';
1101
/**
* Bind `el` event `type` to `fn`.
*
* @param {Element} el
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @return {Function}
* @api public
*/
1112
var bind_1$1 = function(el, type, fn, capture){
 el[bind$1$1](prefix$7 + type, fn, capture || false);
 return fn;
};
1117
/**
* Unbind `el` event `type`'s callback `fn`.
*
* @param {Element} el
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @return {Function}
* @api public
*/
1128
var unbind_1$1 = function(el, type, fn, capture){
 el[unbind$2](prefix$7 + type, fn, capture || false);
 return fn;
};
1133
var componentEvent$1 = {
bind: bind_1$1,
unbind: unbind_1$1
};
1138
/**
* Module dependencies.
*/
1142
/**
* Delegate event `type` to `selector`
* and invoke `fn(e)`. A callback function
* is returned which may be passed to `.unbind()`.
*
* @param {Element} el
* @param {String} selector
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @return {Function}
* @api public
*/
1156
// Some events don't bubble, so we want to bind to the capture phase instead
// when delegating.
var forceCaptureEvents$1 = ['focus', 'blur'];
1160
function bind$2$1(el, selector, type, fn, capture) {
 if (forceCaptureEvents$1.indexOf(type) !== -1) {
   capture = true;
 }
1165
 return componentEvent$1.bind(el, type, function (e) {
   var target = e.target || e.srcElement;
   e.delegateTarget = closest$1(target, selector, true);
   if (e.delegateTarget) {
     fn.call(el, e);
   }
 }, capture);
}
1174
/**
* Unbind event `type`'s callback `fn`.
*
* @param {Element} el
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @api public
*/
function unbind$1$1(el, type, fn, capture) {
 if (forceCaptureEvents$1.indexOf(type) !== -1) {
   capture = true;
 }
1188
 return componentEvent$1.unbind(el, type, fn, capture);
}
1191
var delegate$1 = {
 bind: bind$2$1,
 unbind: unbind$1$1
};
1196
/**
* Expose `parse`.
*/
1200
var domify$1 = parse$2;
1202
/**
* Tests for browser support.
*/
1206
var innerHTMLBug$1 = false;
var bugTestDiv$1;
if (typeof document !== 'undefined') {
 bugTestDiv$1 = document.createElement('div');
 // Setup
 bugTestDiv$1.innerHTML = '  <link/><table></table><a href="/a">a</a><input type="checkbox"/>';
 // Make sure that link elements get serialized correctly by innerHTML
 // This requires a wrapper element in IE
 innerHTMLBug$1 = !bugTestDiv$1.getElementsByTagName('link').length;
 bugTestDiv$1 = undefined;
}
1218
/**
* Wrap map from jquery.
*/
1222
var map$1$1 = {
 legend: [1, '<fieldset>', '</fieldset>'],
 tr: [2, '<table><tbody>', '</tbody></table>'],
 col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
 // for script/link/style tags to work in IE6-8, you have to wrap
 // in a div with a non-whitespace character in front, ha!
 _default: innerHTMLBug$1 ? [1, 'X<div>', '</div>'] : [0, '', '']
};
1231
map$1$1.td =
map$1$1.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
1234
map$1$1.option =
map$1$1.optgroup = [1, '<select multiple="multiple">', '</select>'];
1237
map$1$1.thead =
map$1$1.tbody =
map$1$1.colgroup =
map$1$1.caption =
map$1$1.tfoot = [1, '<table>', '</table>'];
1243
map$1$1.polyline =
map$1$1.ellipse =
map$1$1.polygon =
map$1$1.circle =
map$1$1.text =
map$1$1.line =
map$1$1.path =
map$1$1.rect =
map$1$1.g = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">','</svg>'];
1253
/**
* Parse `html` and return a DOM Node instance, which could be a TextNode,
* HTML DOM Node of some kind (<div> for example), or a DocumentFragment
* instance, depending on the contents of the `html` string.
*
* @param {String} html - HTML string to "domify"
* @param {Document} doc - The `document` instance to create the Node for
* @return {DOMNode} the TextNode, DOM Node, or DocumentFragment instance
* @api private
*/
1264
function parse$2(html, doc) {
 if ('string' != typeof html) throw new TypeError('String expected');
1267
 // default to the global `document` object
 if (!doc) doc = document;
1270
 // tag name
 var m = /<([\w:]+)/.exec(html);
 if (!m) return doc.createTextNode(html);
1274
 html = html.replace(/^\s+|\s+$/g, ''); // Remove leading/trailing whitespace
1276
 var tag = m[1];
1278
 // body support
 if (tag == 'body') {
   var el = doc.createElement('html');
   el.innerHTML = html;
   return el.removeChild(el.lastChild);
 }
1285
 // wrap map
 var wrap = map$1$1[tag] || map$1$1._default;
 var depth = wrap[0];
 var prefix = wrap[1];
 var suffix = wrap[2];
 var el = doc.createElement('div');
 el.innerHTML = prefix + html + suffix;
 while (depth--) el = el.lastChild;
1294
 // one element
 if (el.firstChild == el.lastChild) {
   return el.removeChild(el.firstChild);
 }
1299
 // several elements
 var fragment = doc.createDocumentFragment();
 while (el.firstChild) {
   fragment.appendChild(el.removeChild(el.firstChild));
 }
1305
 return fragment;
}
1308
function query$1(selector, el) {
 el = el || document;
1311
 return el.querySelector(selector);
}
1314
function remove$3(el) {
 el.parentNode && el.parentNode.removeChild(el);
}
1318
function ensureImported(element, target) {
1320
 if (element.ownerDocument !== target.ownerDocument) {
   try {
     // may fail on webkit
     return target.ownerDocument.importNode(element, true);
   } catch (e) {
     // ignore
   }
 }
1329
 return element;
}
1332
/**
* appendTo utility
*/
1336
/**
* 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));
}
1348
/**
* append utility
*/
1352
/**
* 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;
}
1365
/**
* attribute accessor utility
*/
1369
var LENGTH_ATTR = 2;
1371
var CSS_PROPERTIES = {
 'alignment-baseline': 1,
 'baseline-shift': 1,
 'clip': 1,
 'clip-path': 1,
 'clip-rule': 1,
 'color': 1,
 'color-interpolation': 1,
 'color-interpolation-filters': 1,
 'color-profile': 1,
 'color-rendering': 1,
 'cursor': 1,
 'direction': 1,
 'display': 1,
 'dominant-baseline': 1,
 'enable-background': 1,
 'fill': 1,
 'fill-opacity': 1,
 'fill-rule': 1,
 'filter': 1,
 'flood-color': 1,
 'flood-opacity': 1,
 'font': 1,
 'font-family': 1,
 'font-size': LENGTH_ATTR,
 'font-size-adjust': 1,
 'font-stretch': 1,
 'font-style': 1,
 'font-variant': 1,
 'font-weight': 1,
 'glyph-orientation-horizontal': 1,
 'glyph-orientation-vertical': 1,
 'image-rendering': 1,
 'kerning': 1,
 'letter-spacing': 1,
 'lighting-color': 1,
 'marker': 1,
 'marker-end': 1,
 'marker-mid': 1,
 'marker-start': 1,
 'mask': 1,
 'opacity': 1,
 'overflow': 1,
 'pointer-events': 1,
 'shape-rendering': 1,
 'stop-color': 1,
 'stop-opacity': 1,
 'stroke': 1,
 'stroke-dasharray': 1,
 'stroke-dashoffset': 1,
 'stroke-linecap': 1,
 'stroke-linejoin': 1,
 'stroke-miterlimit': 1,
 'stroke-opacity': 1,
 'stroke-width': LENGTH_ATTR,
 'text-anchor': 1,
 'text-decoration': 1,
 'text-rendering': 1,
 'unicode-bidi': 1,
 'visibility': 1,
 'word-spacing': 1,
 'writing-mode': 1
};
1435
1436
function getAttribute(node, name) {
 if (CSS_PROPERTIES[name]) {
   return node.style[name];
 } else {
   return node.getAttributeNS(null, name);
 }
}
1444
function setAttribute(node, name, value) {
 var hyphenated = name.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
1447
 var type = CSS_PROPERTIES[hyphenated];
1449
 if (type) {
   // append pixel unit, unless present
   if (type === LENGTH_ATTR && typeof value === 'number') {
     value = String(value) + 'px';
   }
1455
   node.style[hyphenated] = value;
 } else {
   node.setAttributeNS(null, name, value);
 }
}
1461
function setAttributes(node, attrs) {
1463
 var names = Object.keys(attrs), i, name;
1465
 for (i = 0, name; (name = names[i]); i++) {
   setAttribute(node, name, attrs[name]);
 }
}
1470
/**
* Gets or sets raw attributes on a node.
*
* @param  {SVGElement} node
* @param  {Object} [attrs]
* @param  {String} [name]
* @param  {String} [value]
*
* @return {String}
*/
function attr$1(node, name, value) {
 if (typeof name === 'string') {
   if (value !== undefined) {
     setAttribute(node, name, value);
   } else {
     return getAttribute(node, name);
   }
 } else {
   setAttributes(node, name);
 }
1491
 return node;
}
1494
/**
* Clear utility
*/
function index(arr, obj) {
 if (arr.indexOf) {
   return arr.indexOf(obj);
 }
1502
1503
 for (var i = 0; i < arr.length; ++i) {
   if (arr[i] === obj) {
     return i;
   }
 }
1509
 return -1;
}
1512
var re$1 = /\s+/;
1514
var toString$1 = Object.prototype.toString;
1516
function defined(o) {
 return typeof o !== 'undefined';
}
1520
/**
* Wrap `el` in a `ClassList`.
*
* @param {Element} el
* @return {ClassList}
* @api public
*/
1528
function classes$1(el) {
 return new ClassList$1(el);
}
1532
function ClassList$1(el) {
 if (!el || !el.nodeType) {
   throw new Error('A DOM element reference is required');
 }
 this.el = el;
 this.list = el.classList;
}
1540
/**
* Add class `name` if not already present.
*
* @param {String} name
* @return {ClassList}
* @api public
*/
1548
ClassList$1.prototype.add = function(name) {
1550
 // classList
 if (this.list) {
   this.list.add(name);
   return this;
 }
1556
 // fallback
 var arr = this.array();
 var i = index(arr, name);
 if (!~i) {
   arr.push(name);
 }
1563
 if (defined(this.el.className.baseVal)) {
   this.el.className.baseVal = arr.join(' ');
 } else {
   this.el.className = arr.join(' ');
 }
1569
 return this;
};
1572
/**
* Remove class `name` when present, or
* pass a regular expression to remove
* any which match.
*
* @param {String|RegExp} name
* @return {ClassList}
* @api public
*/
1582
ClassList$1.prototype.remove = function(name) {
 if ('[object RegExp]' === toString$1.call(name)) {
   return this.removeMatching(name);
 }
1587
 // classList
 if (this.list) {
   this.list.remove(name);
   return this;
 }
1593
 // fallback
 var arr = this.array();
 var i = index(arr, name);
 if (~i) {
   arr.splice(i, 1);
 }
 this.el.className.baseVal = arr.join(' ');
 return this;
};
1603
/**
* Remove all classes matching `re`.
*
* @param {RegExp} re
* @return {ClassList}
* @api private
*/
1611
ClassList$1.prototype.removeMatching = function(re) {
 var arr = this.array();
 for (var i = 0; i < arr.length; i++) {
   if (re.test(arr[i])) {
     this.remove(arr[i]);
   }
 }
 return this;
};
1621
/**
* Toggle class `name`, can force state via `force`.
*
* For browsers that support classList, but do not support `force` yet,
* the mistake will be detected and corrected.
*
* @param {String} name
* @param {Boolean} force
* @return {ClassList}
* @api public
*/
1633
ClassList$1.prototype.toggle = function(name, force) {
 // classList
 if (this.list) {
   if (defined(force)) {
     if (force !== this.list.toggle(name, force)) {
       this.list.toggle(name); // toggle again to correct
     }
   } else {
     this.list.toggle(name);
   }
   return this;
 }
1646
 // fallback
 if (defined(force)) {
   if (!force) {
     this.remove(name);
   } else {
     this.add(name);
   }
 } else {
   if (this.has(name)) {
     this.remove(name);
   } else {
     this.add(name);
   }
 }
1661
 return this;
};
1664
/**
* Return an array of classes.
*
* @return {Array}
* @api public
*/
1671
ClassList$1.prototype.array = function() {
 var className = this.el.getAttribute('class') || '';
 var str = className.replace(/^\s+|\s+$/g, '');
 var arr = str.split(re$1);
 if ('' === arr[0]) {
   arr.shift();
 }
 return arr;
};
1681
/**
* Check if class `name` is present.
*
* @param {String} name
* @return {ClassList}
* @api public
*/
1689
ClassList$1.prototype.has =
ClassList$1.prototype.contains = function(name) {
 return (
   this.list ?
     this.list.contains(name) :
     !! ~index(this.array(), name)
 );
};
1698
function remove$2(element) {
 var parent = element.parentNode;
1701
 if (parent) {
   parent.removeChild(element);
 }
1705
 return element;
}
1708
/**
* Clear utility
*/
1712
/**
* Removes all children from the given element
*
* @param  {DOMElement} element
* @return {DOMElement} the element (for chaining)
*/
function clear$1(element) {
 var child;
1721
 while ((child = element.firstChild)) {
   remove$2(child);
 }
1725
 return element;
}
1728
function clone$1(element) {
 return element.cloneNode(true);
}
1732
var ns = {
 svg: 'http://www.w3.org/2000/svg'
};
1736
/**
* DOM parsing utility
*/
1740
var SVG_START = '<svg xmlns="' + ns.svg + '"';
1742
function parse$1(svg) {
1744
 var unwrap = false;
1746
 // ensure we import a valid svg document
 if (svg.substring(0, 4) === '<svg') {
   if (svg.indexOf(ns.svg) === -1) {
     svg = SVG_START + svg.substring(4);
   }
 } else {
   // namespace svg
   svg = SVG_START + '>' + svg + '</svg>';
   unwrap = true;
 }
1757
 var parsed = parseDocument(svg);
1759
 if (!unwrap) {
   return parsed;
 }
1763
 var fragment = document.createDocumentFragment();
1765
 var parent = parsed.firstChild;
1767
 while (parent.firstChild) {
   fragment.appendChild(parent.firstChild);
 }
1771
 return fragment;
}
1774
function parseDocument(svg) {
1776
 var parser;
1778
 // parse
 parser = new DOMParser();
 parser.async = false;
1782
 return parser.parseFromString(svg, 'text/xml');
}
1785
/**
* Create utility for SVG elements
*/
1789
1790
/**
* Create a specific type from name or SVG markup.
*
* @param {String} name the name or markup of the element
* @param {Object} [attrs] attributes to set on the element
*
* @returns {SVGElement}
*/
function create$1(name, attrs) {
 var element;
1801
 if (name.charAt(0) === '<') {
   element = parse$1(name).firstChild;
   element = document.importNode(element, true);
 } else {
   element = document.createElementNS(ns.svg, name);
 }
1808
 if (attrs) {
   attr$1(element, attrs);
 }
1812
 return element;
}
1815
/**
* Geometry helpers
*/
1819
// fake node used to instantiate svg geometry elements
var node = create$1('svg');
1822
function extend$1(object, props) {
 var i, k, keys = Object.keys(props);
1825
 for (i = 0; (k = keys[i]); i++) {
   object[k] = props[k];
 }
1829
 return object;
}
1832
/**
* Create matrix via args.
*
* @example
*
* createMatrix({ a: 1, b: 1 });
* createMatrix();
* createMatrix(1, 2, 0, 0, 30, 20);
*
* @return {SVGMatrix}
*/
function createMatrix(a, b, c, d, e, f) {
 var matrix = node.createSVGMatrix();
1846
 switch (arguments.length) {
 case 0:
   return matrix;
 case 1:
   return extend$1(matrix, a);
 case 6:
   return extend$1(matrix, {
     a: a,
     b: b,
     c: c,
     d: d,
     e: e,
     f: f
   });
 }
}
1863
function createTransform(matrix) {
 if (matrix) {
   return node.createSVGTransformFromMatrix(matrix);
 } else {
   return node.createSVGTransform();
 }
}
1871
/**
* Serialization util
*/
1875
var TEXT_ENTITIES = /([&<>]{1})/g;
var ATTR_ENTITIES = /([\n\r"]{1})/g;
1878
var ENTITY_REPLACEMENT = {
 '&': '&amp;',
 '<': '&lt;',
 '>': '&gt;',
 '"': '\''
};
1885
function escape$1(str, pattern) {
1887
 function replaceFn(match, entity) {
   return ENTITY_REPLACEMENT[entity] || entity;
 }
1891
 return str.replace(pattern, replaceFn);
}
1894
function serialize(node, output) {
1896
 var i, len, attrMap, attrNode, childNodes;
1898
 switch (node.nodeType) {
 // TEXT
 case 3:
   // replace special XML characters
   output.push(escape$1(node.textContent, TEXT_ENTITIES));
   break;
1905
 // ELEMENT
 case 1:
   output.push('<', node.tagName);
1909
   if (node.hasAttributes()) {
     attrMap = node.attributes;
     for (i = 0, len = attrMap.length; i < len; ++i) {
       attrNode = attrMap.item(i);
       output.push(' ', attrNode.name, '="', escape$1(attrNode.value, ATTR_ENTITIES), '"');
     }
   }
1917
   if (node.hasChildNodes()) {
     output.push('>');
     childNodes = node.childNodes;
     for (i = 0, len = childNodes.length; i < len; ++i) {
       serialize(childNodes.item(i), output);
     }
     output.push('</', node.tagName, '>');
   } else {
     output.push('/>');
   }
   break;
1929
 // COMMENT
 case 8:
   output.push('<!--', escape$1(node.nodeValue, TEXT_ENTITIES), '-->');
   break;
1934
 // CDATA
 case 4:
   output.push('<![CDATA[', node.nodeValue, ']]>');
   break;
1939
 default:
   throw new Error('unable to handle node ' + node.nodeType);
 }
1943
 return output;
}
1946
/**
* innerHTML like functionality for SVG elements.
* based on innerSVG (https://code.google.com/p/innersvg)
*/
1951
1952
function set$1(element, svg) {
1954
 var parsed = parse$1(svg);
1956
 // clear element contents
 clear$1(element);
1959
 if (!svg) {
   return;
 }
1963
 if (!isFragment(parsed)) {
   // extract <svg> from parsed document
   parsed = parsed.documentElement;
 }
1968
 var nodes = slice$1(parsed.childNodes);
1970
 // import + append each node
 for (var i = 0; i < nodes.length; i++) {
   appendTo(nodes[i], element);
 }
1975
}
1977
function get$1(element) {
 var child = element.firstChild,
     output = [];
1981
 while (child) {
   serialize(child, output);
   child = child.nextSibling;
 }
1986
 return output.join('');
}
1989
function isFragment(node) {
 return node.nodeName === '#document-fragment';
}
1993
function innerSVG(element, svg) {
1995
 if (svg !== undefined) {
1997
   try {
     set$1(element, svg);
   } catch (e) {
     throw new Error('error parsing SVG: ' + e.message);
   }
2003
   return element;
 } else {
   return get$1(element);
 }
}
2009
2010
function slice$1(arr) {
 return Array.prototype.slice.call(arr);
}
2014
/**
* transform accessor utility
*/
2018
function wrapMatrix(transformList, transform) {
 if (transform instanceof SVGMatrix) {
   return transformList.createSVGTransformFromMatrix(transform);
 }
2023
 return transform;
}
2026
2027
function setTransforms(transformList, transforms) {
 var i, t;
2030
 transformList.clear();
2032
 for (i = 0; (t = transforms[i]); i++) {
   transformList.appendItem(wrapMatrix(transformList, t));
 }
}
2037
/**
* Get or set the transforms on the given node.
*
* @param {SVGElement} node
* @param  {SVGTransform|SVGMatrix|Array<SVGTransform|SVGMatrix>} [transforms]
*
* @return {SVGTransform} the consolidated transform
*/
function transform$1(node, transforms) {
 var transformList = node.transform.baseVal;
2048
 if (transforms) {
2050
   if (!Array.isArray(transforms)) {
     transforms = [ transforms ];
   }
2054
   setTransforms(transformList, transforms);
 }
2057
 return transformList.consolidate();
}
2060
var CLASS_PATTERN = /^class /;
2062
function isClass(fn) {
 return CLASS_PATTERN.test(fn.toString());
}
2066
function isArray$2(obj) {
 return Object.prototype.toString.call(obj) === '[object Array]';
}
2070
function hasOwnProp(obj, prop) {
 return Object.prototype.hasOwnProperty.call(obj, prop);
}
2074
function annotate() {
 var args = Array.prototype.slice.call(arguments);
2077
 if (args.length === 1 && isArray$2(args[0])) {
   args = args[0];
 }
2081
 var fn = args.pop();
2083
 fn.$inject = args;
2085
 return fn;
}
2088
2089
// Current limitations:
// - can't put into "function arg" comments
// function /* (no parenthesis like this) */ (){}
// function abc( /* xx (no parenthesis like this) */ a, b) {}
//
// Just put the comment before function or inside:
// /* (((this is fine))) */ function(a, b) {}
// function abc(a) { /* (((this is fine))) */}
//
// - can't reliably auto-annotate constructor; we'll match the
// first constructor(...) pattern found which may be the one
// of a nested class, too.
2102
var CONSTRUCTOR_ARGS = /constructor\s*[^(]*\(\s*([^)]*)\)/m;
var FN_ARGS = /^(?:async )?(?:function\s*)?[^(]*\(\s*([^)]*)\)/m;
var FN_ARG = /\/\*([^*]*)\*\//m;
2106
function parseAnnotations(fn) {
2108
 if (typeof fn !== 'function') {
   throw new Error('Cannot annotate "' + fn + '". Expected a function!');
 }
2112
 var match = fn.toString().match(isClass(fn) ? CONSTRUCTOR_ARGS : FN_ARGS);
2114
 // may parse class without constructor
 if (!match) {
   return [];
 }
2119
 return match[1] && match[1].split(',').map(function(arg) {
   match = arg.match(FN_ARG);
   return match ? match[1].trim() : arg.trim();
 }) || [];
}
2125
function Module() {
 var providers = [];
2128
 this.factory = function(name, factory) {
   providers.push([name, 'factory', factory]);
   return this;
 };
2133
 this.value = function(name, value) {
   providers.push([name, 'value', value]);
   return this;
 };
2138
 this.type = function(name, type) {
   providers.push([name, 'type', type]);
   return this;
 };
2143
 this.forEach = function(iterator) {
   providers.forEach(iterator);
 };
2147
}
2149
function Injector(modules, parent) {
 parent = parent || {
   get: function(name, strict) {
     currentlyResolving.push(name);
2154
     if (strict === false) {
       return null;
     } else {
       throw error('No provider for "' + name + '"!');
     }
   }
 };
2162
 var currentlyResolving = [];
 var providers = this._providers = Object.create(parent._providers || null);
 var instances = this._instances = Object.create(null);
2166
 var self = instances.injector = this;
2168
 var error = function(msg) {
   var stack = currentlyResolving.join(' -> ');
   currentlyResolving.length = 0;
   return new Error(stack ? msg + ' (Resolving: ' + stack + ')' : msg);
 };
2174
 /**
  * Return a named service.
  *
  * @param {String} name
  * @param {Boolean} [strict=true] if false, resolve missing services to null
  *
  * @return {Object}
  */
 var get = function(name, strict) {
   if (!providers[name] && name.indexOf('.') !== -1) {
     var parts = name.split('.');
     var pivot = get(parts.shift());
2187
     while (parts.length) {
       pivot = pivot[parts.shift()];
     }
2191
     return pivot;
   }
2194
   if (hasOwnProp(instances, name)) {
     return instances[name];
   }
2198
   if (hasOwnProp(providers, name)) {
     if (currentlyResolving.indexOf(name) !== -1) {
       currentlyResolving.push(name);
       throw error('Cannot resolve circular dependency!');
     }
2204
     currentlyResolving.push(name);
     instances[name] = providers[name][0](providers[name][1]);
     currentlyResolving.pop();
2208
     return instances[name];
   }
2211
   return parent.get(name, strict);
 };
2214
 var fnDef = function(fn, locals) {
2216
   if (typeof locals === 'undefined') {
     locals = {};
   }
2220
   if (typeof fn !== 'function') {
     if (isArray$2(fn)) {
       fn = annotate(fn.slice());
     } else {
       throw new Error('Cannot invoke "' + fn + '". Expected a function!');
     }
   }
2228
   var inject = fn.$inject || parseAnnotations(fn);
   var dependencies = inject.map(function(dep) {
     if (hasOwnProp(locals, dep)) {
       return locals[dep];
     } else {
       return get(dep);
     }
   });
2237
   return {
     fn: fn,
     dependencies: dependencies
   };
 };
2243
 var instantiate = function(Type) {
   var def = fnDef(Type);
2246
   var fn = def.fn,
       dependencies = def.dependencies;
2249
   // instantiate var args constructor
   var Constructor = Function.prototype.bind.apply(fn, [ null ].concat(dependencies));
2252
   return new Constructor();
 };
2255
 var invoke = function(func, context, locals) {
   var def = fnDef(func, locals);
2258
   var fn = def.fn,
       dependencies = def.dependencies;
2261
   return fn.apply(context, dependencies);
 };
2264
2265
 var createPrivateInjectorFactory = function(privateChildInjector) {
   return annotate(function(key) {
     return privateChildInjector.get(key);
   });
 };
2271
 var createChild = function(modules, forceNewInstances) {
   if (forceNewInstances && forceNewInstances.length) {
     var fromParentModule = Object.create(null);
     var matchedScopes = Object.create(null);
2276
     var privateInjectorsCache = [];
     var privateChildInjectors = [];
     var privateChildFactories = [];
2280
     var provider;
     var cacheIdx;
     var privateChildInjector;
     var privateChildInjectorFactory;
     for (var name in providers) {
       provider = providers[name];
2287
       if (forceNewInstances.indexOf(name) !== -1) {
         if (provider[2] === 'private') {
           cacheIdx = privateInjectorsCache.indexOf(provider[3]);
           if (cacheIdx === -1) {
             privateChildInjector = provider[3].createChild([], forceNewInstances);
             privateChildInjectorFactory = createPrivateInjectorFactory(privateChildInjector);
             privateInjectorsCache.push(provider[3]);
             privateChildInjectors.push(privateChildInjector);
             privateChildFactories.push(privateChildInjectorFactory);
             fromParentModule[name] = [privateChildInjectorFactory, name, 'private', privateChildInjector];
           } else {
             fromParentModule[name] = [privateChildFactories[cacheIdx], name, 'private', privateChildInjectors[cacheIdx]];
           }
         } else {
           fromParentModule[name] = [provider[2], provider[1]];
         }
         matchedScopes[name] = true;
       }
2306
       if ((provider[2] === 'factory' || provider[2] === 'type') && provider[1].$scope) {
         /* jshint -W083 */
         forceNewInstances.forEach(function(scope) {
           if (provider[1].$scope.indexOf(scope) !== -1) {
             fromParentModule[name] = [provider[2], provider[1]];
             matchedScopes[scope] = true;
           }
         });
       }
     }
2317
     forceNewInstances.forEach(function(scope) {
       if (!matchedScopes[scope]) {
         throw new Error('No provider for "' + scope + '". Cannot use provider from the parent!');
       }
     });
2323
     modules.unshift(fromParentModule);
   }
2326
   return new Injector(modules, self);
 };
2329
 var factoryMap = {
   factory: invoke,
   type: instantiate,
   value: function(value) {
     return value;
   }
 };
2337
 modules.forEach(function(module) {
2339
   function arrayUnwrap(type, value) {
     if (type !== 'value' && isArray$2(value)) {
       value = annotate(value.slice());
     }
2344
     return value;
   }
2347
   // TODO(vojta): handle wrong inputs (modules)
   if (module instanceof Module) {
     module.forEach(function(provider) {
       var name = provider[0];
       var type = provider[1];
       var value = provider[2];
2354
       providers[name] = [factoryMap[type], arrayUnwrap(type, value), type];
     });
   } else if (typeof module === 'object') {
     if (module.__exports__) {
       var clonedModule = Object.keys(module).reduce(function(m, key) {
         if (key.substring(0, 2) !== '__') {
           m[key] = module[key];
         }
         return m;
       }, Object.create(null));
2365
       var privateInjector = new Injector((module.__modules__ || []).concat([clonedModule]), self);
       var getFromPrivateInjector = annotate(function(key) {
         return privateInjector.get(key);
       });
       module.__exports__.forEach(function(key) {
         providers[key] = [getFromPrivateInjector, key, 'private', privateInjector];
       });
     } else {
       Object.keys(module).forEach(function(name) {
         if (module[name][2] === 'private') {
           providers[name] = module[name];
           return;
         }
2379
         var type = module[name][0];
         var value = module[name][1];
2382
         providers[name] = [factoryMap[type], arrayUnwrap(type, value), type];
       });
     }
   }
 });
2388
 // public API
 this.get = get;
 this.invoke = invoke;
 this.instantiate = instantiate;
 this.createChild = createChild;
}
2395
var DEFAULT_RENDER_PRIORITY$1 = 1000;
2397
/**
* The base implementation of shape and connection renderers.
*
* @param {EventBus} eventBus
* @param {number} [renderPriority=1000]
*/
function BaseRenderer(eventBus, renderPriority) {
 var self = this;
2406
 renderPriority = renderPriority || DEFAULT_RENDER_PRIORITY$1;
2408
 eventBus.on([ 'render.shape', 'render.connection' ], renderPriority, function(evt, context) {
   var type = evt.type,
       element = context.element,
       visuals = context.gfx,
       attrs = context.attrs;
2414
   if (self.canRender(element)) {
     if (type === 'render.shape') {
       return self.drawShape(visuals, element, attrs);
     } else {
       return self.drawConnection(visuals, element, attrs);
     }
   }
 });
2423
 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);
     }
   }
 });
}
2434
/**
* Should check whether *this* renderer can render
* the element/connection.
*
* @param {element} element
*
* @returns {boolean}
*/
BaseRenderer.prototype.canRender = function() {};
2444
/**
* Provides the shape's snap svg element to be drawn on the `canvas`.
*
* @param {djs.Graphics} visuals
* @param {Shape} shape
*
* @returns {Snap.svg} [returns a Snap.svg paper element ]
*/
BaseRenderer.prototype.drawShape = function() {};
2454
/**
* Provides the shape's snap svg element to be drawn on the `canvas`.
*
* @param {djs.Graphics} visuals
* @param {Connection} connection
*
* @returns {Snap.svg} [returns a Snap.svg paper element ]
*/
BaseRenderer.prototype.drawConnection = function() {};
2464
/**
* Gets the SVG path of a shape that represents it's visual bounds.
*
* @param {Shape} shape
*
* @return {string} svg path
*/
BaseRenderer.prototype.getShapePath = function() {};
2473
/**
* Gets the SVG path of a connection that represents it's visual bounds.
*
* @param {Connection} connection
*
* @return {string} svg path
*/
BaseRenderer.prototype.getConnectionPath = function() {};
2482
function componentsToPath(elements) {
 return elements.join(',').replace(/,?([A-z]),?/g, '$1');
}
2486
function toSVGPoints(points) {
 var result = '';
2489
 for (var i = 0, p; (p = points[i]); i++) {
   result += p.x + ',' + p.y + ' ';
 }
2493
 return result;
}
2496
function createLine(points, attrs) {
2498
 var line = create$1('polyline');
 attr$1(line, { points: toSVGPoints(points) });
2501
 if (attrs) {
   attr$1(line, attrs);
 }
2505
 return line;
}
2508
function updateLine(gfx, points) {
 attr$1(gfx, { points: toSVGPoints(points) });
2511
 return gfx;
}
2514
/**
* Get parent elements.
*
* @param {Array<djs.model.base>} elements
*
* @returns {Array<djs.model.Base>}
*/
function getParents$1(elements) {
2523
 // find elements that are not children of any other elements
 return filter(elements, function(element) {
   return !find(elements, function(e) {
     return e !== element && getParent$1(element, e);
   });
 });
}
2531
2532
function getParent$1(element, parent) {
 if (!parent) {
   return;
 }
2537
 if (element === parent) {
   return parent;
 }
2541
 if (!element.parent) {
   return;
 }
2545
 return getParent$1(element.parent, parent);
}
2548
2549
/**
* Adds an element to a collection and returns true if the
* element was added.
*
* @param {Array<Object>} elements
* @param {Object} e
* @param {boolean} unique
*/
function add$1(elements, e, unique) {
 var canAdd = !unique || elements.indexOf(e) === -1;
2560
 if (canAdd) {
   elements.push(e);
 }
2564
 return canAdd;
}
2567
2568
/**
* Iterate over each element in a collection, calling the iterator function `fn`
* with (element, index, recursionDepth).
*
* Recurse into all elements that are returned by `fn`.
*
* @param  {Object|Array<Object>} elements
* @param  {Function} fn iterator function called with (element, index, recursionDepth)
* @param  {number} [depth] maximum recursion depth
*/
function eachElement(elements, fn, depth) {
2580
 depth = depth || 0;
2582
 if (!isArray$4(elements)) {
   elements = [ elements ];
 }
2586
 forEach$2(elements, function(s, i) {
   var filter = fn(s, i, depth);
2589
   if (isArray$4(filter) && filter.length) {
     eachElement(filter, fn, depth + 1);
   }
 });
}
2595
2596
/**
* Collects self + child elements up to a given depth from a list of elements.
*
* @param  {djs.model.Base|Array<djs.model.Base>} elements the elements to select the children from
* @param  {boolean} unique whether to return a unique result set (no duplicates)
* @param  {number} maxDepth the depth to search through or -1 for infinite
*
* @return {Array<djs.model.Base>} found elements
*/
function selfAndChildren(elements, unique, maxDepth) {
 var result = [],
     processedChildren = [];
2609
 eachElement(elements, function(element, i, depth) {
   add$1(result, element, unique);
2612
   var children = element.children;
2614
   // max traversal depth not reached yet
   if (maxDepth === -1 || depth < maxDepth) {
2617
     // children exist && children not yet processed
     if (children && add$1(processedChildren, children, unique)) {
       return children;
     }
   }
 });
2624
 return result;
}
2627
2628
/**
* Return self + ALL children for a number of elements
*
* @param  {Array<djs.model.Base>} elements to query
* @param  {boolean} allowDuplicates to allow duplicates in the result set
*
* @return {Array<djs.model.Base>} the collected elements
*/
function selfAndAllChildren(elements, allowDuplicates) {
 return selfAndChildren(elements, !allowDuplicates, -1);
}
2640
2641
/**
* Gets the the closure for all selected elements,
* their enclosed children and connections.
*
* @param {Array<djs.model.Base>} elements
* @param {boolean} [isTopLevel=true]
* @param {Object} [existingClosure]
*
* @return {Object} newClosure
*/
function getClosure(elements, isTopLevel, closure) {
2653
 if (isUndefined$3(isTopLevel)) {
   isTopLevel = true;
 }
2657
 if (isObject(isTopLevel)) {
   closure = isTopLevel;
   isTopLevel = true;
 }
2662
2663
 closure = closure || {};
2665
 var allShapes = copyObject(closure.allShapes),
     allConnections = copyObject(closure.allConnections),
     enclosedElements = copyObject(closure.enclosedElements),
     enclosedConnections = copyObject(closure.enclosedConnections);
2670
 var topLevel = copyObject(
   closure.topLevel,
   isTopLevel && groupBy(elements, function(e) { return e.id; })
 );
2675
2676
 function handleConnection(c) {
   if (topLevel[c.source.id] && topLevel[c.target.id]) {
     topLevel[c.id] = [ c ];
   }
2681
   // not enclosed as a child, but maybe logically
   // (connecting two moved elements?)
   if (allShapes[c.source.id] && allShapes[c.target.id]) {
     enclosedConnections[c.id] = enclosedElements[c.id] = c;
   }
2687
   allConnections[c.id] = c;
 }
2690
 function handleElement(element) {
2692
   enclosedElements[element.id] = element;
2694
   if (element.waypoints) {
2696
     // remember connection
     enclosedConnections[element.id] = allConnections[element.id] = element;
   } else {
2700
     // remember shape
     allShapes[element.id] = element;
2703
     // remember all connections
     forEach$2(element.incoming, handleConnection);
2706
     forEach$2(element.outgoing, handleConnection);
2708
     // recurse into children
     return element.children;
   }
 }
2713
 eachElement(elements, handleElement);
2715
 return {
   allShapes: allShapes,
   allConnections: allConnections,
   topLevel: topLevel,
   enclosedConnections: enclosedConnections,
   enclosedElements: enclosedElements
 };
}
2724
/**
* Returns the surrounding bbox for all elements in
* the array or the element primitive.
*
* @param {Array<djs.model.Shape>|djs.model.Shape} elements
* @param {boolean} stopRecursion
*/
function getBBox(elements, stopRecursion) {
2733
 stopRecursion = !!stopRecursion;
 if (!isArray$4(elements)) {
   elements = [ elements ];
 }
2738
 var minX,
     minY,
     maxX,
     maxY;
2743
 forEach$2(elements, function(element) {
2745
   // If element is a connection the bbox must be computed first
   var bbox = element;
   if (element.waypoints && !stopRecursion) {
     bbox = getBBox(element.waypoints, true);
   }
2751
   var x = bbox.x,
       y = bbox.y,
       height = bbox.height || 0,
       width = bbox.width || 0;
2756
   if (x < minX || minX === undefined) {
     minX = x;
   }
   if (y < minY || minY === undefined) {
     minY = y;
   }
2763
   if ((x + width) > maxX || maxX === undefined) {
     maxX = x + width;
   }
   if ((y + height) > maxY || maxY === undefined) {
     maxY = y + height;
   }
 });
2771
 return {
   x: minX,
   y: minY,
   height: maxY - minY,
   width: maxX - minX
 };
}
2779
2780
/**
* Returns all elements that are enclosed from the bounding box.
*
*   * If bbox.(width|height) is not specified the method returns
*     all elements with element.x/y > bbox.x/y
*   * If only bbox.x or bbox.y is specified, method return all elements with
*     e.x > bbox.x or e.y > bbox.y
*
* @param {Array<djs.model.Shape>} elements List of Elements to search through
* @param {djs.model.Shape} bbox the enclosing bbox.
*
* @return {Array<djs.model.Shape>} enclosed elements
*/
function getEnclosedElements(elements, bbox) {
2795
 var filteredElements = {};
2797
 forEach$2(elements, function(element) {
2799
   var e = element;
2801
   if (e.waypoints) {
     e = getBBox(e);
   }
2805
   if (!isNumber(bbox.y) && (e.x > bbox.x)) {
     filteredElements[element.id] = element;
   }
   if (!isNumber(bbox.x) && (e.y > bbox.y)) {
     filteredElements[element.id] = element;
   }
   if (e.x > bbox.x && e.y > bbox.y) {
     if (isNumber(bbox.width) && isNumber(bbox.height) &&
         e.width + e.x < bbox.width + bbox.x &&
         e.height + e.y < bbox.height + bbox.y) {
2816
       filteredElements[element.id] = element;
     } else if (!isNumber(bbox.width) || !isNumber(bbox.height)) {
       filteredElements[element.id] = element;
     }
   }
 });
2823
 return filteredElements;
}
2826
2827
function getType(element) {
2829
 if ('waypoints' in element) {
   return 'connection';
 }
2833
 if ('x' in element) {
   return 'shape';
 }
2837
 return 'root';
}
2840
function isFrameElement$1(element) {
2842
 return !!(element && element.isFrame);
}
2845
// helpers ///////////////////////////////
2847
function copyObject(src1, src2) {
 return assign({}, src1 || {}, src2 || {});
}
2851
// apply default renderer with lowest possible priority
// so that it only kicks in if noone else could render
var DEFAULT_RENDER_PRIORITY = 1;
2855
/**
* The default renderer used for shapes and connections.
*
* @param {EventBus} eventBus
* @param {Styles} styles
*/
function DefaultRenderer(eventBus, styles) {
2863
 //
 BaseRenderer.call(this, eventBus, DEFAULT_RENDER_PRIORITY);
2866
 this.CONNECTION_STYLE = styles.style([ 'no-fill' ], { strokeWidth: 5, stroke: 'fuchsia' });
 this.SHAPE_STYLE = styles.style({ fill: 'white', stroke: 'fuchsia', strokeWidth: 2 });
 this.FRAME_STYLE = styles.style([ 'no-fill' ], { stroke: 'fuchsia', strokeDasharray: 4, strokeWidth: 2 });
}
2871
inherits$1(DefaultRenderer, BaseRenderer);
2873
2874
DefaultRenderer.prototype.canRender = function() {
 return true;
};
2878
DefaultRenderer.prototype.drawShape = function drawShape(visuals, element, attrs) {
 var rect = create$1('rect');
2881
 attr$1(rect, {
   x: 0,
   y: 0,
   width: element.width || 0,
   height: element.height || 0
 });
2888
 if (isFrameElement$1(element)) {
   attr$1(rect, assign({}, this.FRAME_STYLE, attrs || {}));
 } else {
   attr$1(rect, assign({}, this.SHAPE_STYLE, attrs || {}));
 }
2894
 append(visuals, rect);
2896
 return rect;
};
2899
DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection, attrs) {
2901
 var line = createLine(connection.waypoints, assign({}, this.CONNECTION_STYLE, attrs || {}));
 append(visuals, line);
2904
 return line;
};
2907
DefaultRenderer.prototype.getShapePath = function getShapePath(shape) {
2909
 var x = shape.x,
     y = shape.y,
     width = shape.width,
     height = shape.height;
2914
 var shapePath = [
   [ 'M', x, y ],
   [ 'l', width, 0 ],
   [ 'l', 0, height ],
   [ 'l', -width, 0 ],
   [ 'z' ]
 ];
2922
 return componentsToPath(shapePath);
};
2925
DefaultRenderer.prototype.getConnectionPath = function getConnectionPath(connection) {
 var waypoints = connection.waypoints;
2928
 var idx, point, connectionPath = [];
2930
 for (idx = 0; (point = waypoints[idx]); idx++) {
2932
   // take invisible docking into account
   // when creating the path
   point = point.original || point;
2936
   connectionPath.push([ idx === 0 ? 'M' : 'L', point.x, point.y ]);
 }
2939
 return componentsToPath(connectionPath);
};
2942
2943
DefaultRenderer.$inject = [ 'eventBus', 'styles' ];
2945
/**
* A component that manages shape styles
*/
function Styles() {
2950
 var defaultTraits = {
2952
   'no-fill': {
     fill: 'none'
   },
   'no-border': {
     strokeOpacity: 0.0
   },
   'no-events': {
     pointerEvents: 'none'
   }
 };
2963
 var self = this;
2965
 /**
  * Builds a style definition from a className, a list of traits and an object of additional attributes.
  *
  * @param  {string} className
  * @param  {Array<string>} traits
  * @param  {Object} additionalAttrs
  *
  * @return {Object} the style defintion
  */
 this.cls = function(className, traits, additionalAttrs) {
   var attrs = this.style(traits, additionalAttrs);
2977
   return assign(attrs, { 'class': className });
 };
2980
 /**
  * Builds a style definition from a list of traits and an object of additional attributes.
  *
  * @param  {Array<string>} traits
  * @param  {Object} additionalAttrs
  *
  * @return {Object} the style defintion
  */
 this.style = function(traits, additionalAttrs) {
2990
   if (!isArray$4(traits) && !additionalAttrs) {
     additionalAttrs = traits;
     traits = [];
   }
2995
   var attrs = reduce(traits, function(attrs, t) {
     return assign(attrs, defaultTraits[t] || {});
   }, {});
2999
   return additionalAttrs ? assign(attrs, additionalAttrs) : attrs;
 };
3002
 this.computeStyle = function(custom, traits, defaultStyles) {
   if (!isArray$4(traits)) {
     defaultStyles = traits;
     traits = [];
   }
3008
   return self.style(traits || [], assign({}, defaultStyles, custom || {}));
 };
}
3012
var DrawModule$1 = {
 __init__: [ 'defaultRenderer' ],
 defaultRenderer: [ 'type', DefaultRenderer ],
 styles: [ 'type', Styles ]
};
3018
/**
* Flatten array, one level deep.
*
* @param {Array<?>} arr
*
* @return {Array<?>}
*/
3026
var nativeToString = Object.prototype.toString;
var nativeHasOwnProperty = Object.prototype.hasOwnProperty;
function isUndefined$1(obj) {
 return obj === undefined;
}
function isArray$1(obj) {
 return nativeToString.call(obj) === '[object Array]';
}
/**
* Return true, if target owns a property with the given key.
*
* @param {Object} target
* @param {String} key
*
* @return {Boolean}
*/
3043
function has(target, key) {
 return nativeHasOwnProperty.call(target, key);
}
/**
* Iterate over collection; returning something
* (non-undefined) will stop iteration.
*
* @param  {Array|Object} collection
* @param  {Function} iterator
*
* @return {Object} return result that stopped the iteration
*/
3056
function forEach(collection, iterator) {
 var val, result;
3059
 if (isUndefined$1(collection)) {
   return;
 }
3063
 var convertKey = isArray$1(collection) ? toNum : identity;
3065
 for (var key in collection) {
   if (has(collection, key)) {
     val = collection[key];
     result = iterator(val, convertKey(key));
3070
     if (result === false) {
       return val;
     }
   }
 }
}
3077
function identity(arg) {
 return arg;
}
3081
function toNum(arg) {
 return Number(arg);
}
3085
/**
* Assigns style attributes in a style-src compliant way.
*
* @param {Element} element
* @param {...Object} styleSources
*
* @return {Element} the element
*/
function assign$1(element) {
 var target = element.style;
3096
 for (var _len = arguments.length, styleSources = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
   styleSources[_key - 1] = arguments[_key];
 }
3100
 forEach(styleSources, function (style) {
   if (!style) {
     return;
   }
3105
   forEach(style, function (value, key) {
     target[key] = value;
   });
 });
3110
 return element;
}
3113
/**
* Set attribute `name` to `val`, or get attr `name`.
*
* @param {Element} el
* @param {String} name
* @param {String} [val]
* @api public
*/
function attr(el, name, val) {
 // get
 if (arguments.length == 2) {
   return el.getAttribute(name);
 }
3127
 // remove
 if (val === null) {
   return el.removeAttribute(name);
 }
3132
 // set
 el.setAttribute(name, val);
3135
 return el;
}
3138
var indexOf$1 = [].indexOf;
3140
var indexof = function(arr, obj){
 if (indexOf$1) return arr.indexOf(obj);
 for (var i = 0; i < arr.length; ++i) {
   if (arr[i] === obj) return i;
 }
 return -1;
};
3148
/**
* Taken from https://github.com/component/classes
*
* Without the component bits.
*/
3154
/**
* Whitespace regexp.
*/
3158
var re = /\s+/;
3160
/**
* toString reference.
*/
3164
var toString = Object.prototype.toString;
3166
/**
* Wrap `el` in a `ClassList`.
*
* @param {Element} el
* @return {ClassList}
* @api public
*/
3174
function classes(el) {
 return new ClassList(el);
}
3178
/**
* Initialize a new ClassList for `el`.
*
* @param {Element} el
* @api private
*/
3185
function ClassList(el) {
 if (!el || !el.nodeType) {
   throw new Error('A DOM element reference is required');
 }
 this.el = el;
 this.list = el.classList;
}
3193
/**
* Add class `name` if not already present.
*
* @param {String} name
* @return {ClassList}
* @api public
*/
3201
ClassList.prototype.add = function (name) {
 // classList
 if (this.list) {
   this.list.add(name);
   return this;
 }
3208
 // fallback
 var arr = this.array();
 var i = indexof(arr, name);
 if (!~i) arr.push(name);
 this.el.className = arr.join(' ');
 return this;
};
3216
/**
* Remove class `name` when present, or
* pass a regular expression to remove
* any which match.
*
* @param {String|RegExp} name
* @return {ClassList}
* @api public
*/
3226
ClassList.prototype.remove = function (name) {
 if ('[object RegExp]' == toString.call(name)) {
   return this.removeMatching(name);
 }
3231
 // classList
 if (this.list) {
   this.list.remove(name);
   return this;
 }
3237
 // fallback
 var arr = this.array();
 var i = indexof(arr, name);
 if (~i) arr.splice(i, 1);
 this.el.className = arr.join(' ');
 return this;
};
3245
/**
* Remove all classes matching `re`.
*
* @param {RegExp} re
* @return {ClassList}
* @api private
*/
3253
ClassList.prototype.removeMatching = function (re) {
 var arr = this.array();
 for (var i = 0; i < arr.length; i++) {
   if (re.test(arr[i])) {
     this.remove(arr[i]);
   }
 }
 return this;
};
3263
/**
* Toggle class `name`, can force state via `force`.
*
* For browsers that support classList, but do not support `force` yet,
* the mistake will be detected and corrected.
*
* @param {String} name
* @param {Boolean} force
* @return {ClassList}
* @api public
*/
3275
ClassList.prototype.toggle = function (name, force) {
 // classList
 if (this.list) {
   if ('undefined' !== typeof force) {
     if (force !== this.list.toggle(name, force)) {
       this.list.toggle(name); // toggle again to correct
     }
   } else {
     this.list.toggle(name);
   }
   return this;
 }
3288
 // fallback
 if ('undefined' !== typeof force) {
   if (!force) {
     this.remove(name);
   } else {
     this.add(name);
   }
 } else {
   if (this.has(name)) {
     this.remove(name);
   } else {
     this.add(name);
   }
 }
3303
 return this;
};
3306
/**
* Return an array of classes.
*
* @return {Array}
* @api public
*/
3313
ClassList.prototype.array = function () {
 var className = this.el.getAttribute('class') || '';
 var str = className.replace(/^\s+|\s+$/g, '');
 var arr = str.split(re);
 if ('' === arr[0]) arr.shift();
 return arr;
};
3321
/**
* Check if class `name` is present.
*
* @param {String} name
* @return {ClassList}
* @api public
*/
3329
ClassList.prototype.has = ClassList.prototype.contains = function (name) {
 return this.list ? this.list.contains(name) : !!~indexof(this.array(), name);
};
3333
/**
* Remove all children from the given element.
*/
function clear(el) {
3338
 var c;
3340
 while (el.childNodes.length) {
   c = el.childNodes[0];
   el.removeChild(c);
 }
3345
 return el;
}
3348
var proto = typeof Element !== 'undefined' ? Element.prototype : {};
var vendor = proto.matches
 || proto.matchesSelector
 || proto.webkitMatchesSelector
 || proto.mozMatchesSelector
 || proto.msMatchesSelector
 || proto.oMatchesSelector;
3356
var matchesSelector = match;
3358
/**
* Match `el` to `selector`.
*
* @param {Element} el
* @param {String} selector
* @return {Boolean}
* @api public
*/
3367
function match(el, selector) {
 if (!el || el.nodeType !== 1) return false;
 if (vendor) return vendor.call(el, selector);
 var nodes = el.parentNode.querySelectorAll(selector);
 for (var i = 0; i < nodes.length; i++) {
   if (nodes[i] == el) return true;
 }
 return false;
}
3377
/**
* Closest
*
* @param {Element} el
* @param {String} selector
* @param {Boolean} checkYourSelf (optional)
*/
function closest (element, selector, checkYourSelf) {
 var currentElem = checkYourSelf ? element : element.parentNode;
3387
 while (currentElem && currentElem.nodeType !== document.DOCUMENT_NODE && currentElem.nodeType !== document.DOCUMENT_FRAGMENT_NODE) {
3389
   if (matchesSelector(currentElem, selector)) {
     return currentElem;
   }
3393
   currentElem = currentElem.parentNode;
 }
3396
 return matchesSelector(currentElem, selector) ? currentElem : null;
}
3399
var bind$1 = window.addEventListener ? 'addEventListener' : 'attachEvent',
   unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
   prefix$6 = bind$1 !== 'addEventListener' ? 'on' : '';
3403
/**
* Bind `el` event `type` to `fn`.
*
* @param {Element} el
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @return {Function}
* @api public
*/
3414
var bind_1 = function(el, type, fn, capture){
 el[bind$1](prefix$6 + type, fn, capture || false);
 return fn;
};
3419
/**
* Unbind `el` event `type`'s callback `fn`.
*
* @param {Element} el
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @return {Function}
* @api public
*/
3430
var unbind_1 = function(el, type, fn, capture){
 el[unbind](prefix$6 + type, fn, capture || false);
 return fn;
};
3435
var componentEvent = {
bind: bind_1,
unbind: unbind_1
};
3440
/**
* Module dependencies.
*/
3444
/**
* Delegate event `type` to `selector`
* and invoke `fn(e)`. A callback function
* is returned which may be passed to `.unbind()`.
*
* @param {Element} el
* @param {String} selector
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @return {Function}
* @api public
*/
3458
// Some events don't bubble, so we want to bind to the capture phase instead
// when delegating.
var forceCaptureEvents = ['focus', 'blur'];
3462
function bind$2(el, selector, type, fn, capture) {
 if (forceCaptureEvents.indexOf(type) !== -1) {
   capture = true;
 }
3467
 return componentEvent.bind(el, type, function (e) {
   var target = e.target || e.srcElement;
   e.delegateTarget = closest(target, selector, true);
   if (e.delegateTarget) {
     fn.call(el, e);
   }
 }, capture);
}
3476
/**
* Unbind event `type`'s callback `fn`.
*
* @param {Element} el
* @param {String} type
* @param {Function} fn
* @param {Boolean} capture
* @api public
*/
function unbind$1(el, type, fn, capture) {
 if (forceCaptureEvents.indexOf(type) !== -1) {
   capture = true;
 }
3490
 return componentEvent.unbind(el, type, fn, capture);
}
3493
var delegate = {
 bind: bind$2,
 unbind: unbind$1
};
3498
/**
* Expose `parse`.
*/
3502
var domify = parse;
3504
/**
* Tests for browser support.
*/
3508
var innerHTMLBug = false;
var bugTestDiv;
if (typeof document !== 'undefined') {
 bugTestDiv = document.createElement('div');
 // Setup
 bugTestDiv.innerHTML = '  <link/><table></table><a href="/a">a</a><input type="checkbox"/>';
 // Make sure that link elements get serialized correctly by innerHTML
 // This requires a wrapper element in IE
 innerHTMLBug = !bugTestDiv.getElementsByTagName('link').length;
 bugTestDiv = undefined;
}
3520
/**
* Wrap map from jquery.
*/
3524
var map$1 = {
 legend: [1, '<fieldset>', '</fieldset>'],
 tr: [2, '<table><tbody>', '</tbody></table>'],
 col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
 // for script/link/style tags to work in IE6-8, you have to wrap
 // in a div with a non-whitespace character in front, ha!
 _default: innerHTMLBug ? [1, 'X<div>', '</div>'] : [0, '', '']
};
3533
map$1.td =
map$1.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
3536
map$1.option =
map$1.optgroup = [1, '<select multiple="multiple">', '</select>'];
3539
map$1.thead =
map$1.tbody =
map$1.colgroup =
map$1.caption =
map$1.tfoot = [1, '<table>', '</table>'];
3545
map$1.polyline =
map$1.ellipse =
map$1.polygon =
map$1.circle =
map$1.text =
map$1.line =
map$1.path =
map$1.rect =
map$1.g = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">','</svg>'];
3555
/**
* Parse `html` and return a DOM Node instance, which could be a TextNode,
* HTML DOM Node of some kind (<div> for example), or a DocumentFragment
* instance, depending on the contents of the `html` string.
*
* @param {String} html - HTML string to "domify"
* @param {Document} doc - The `document` instance to create the Node for
* @return {DOMNode} the TextNode, DOM Node, or DocumentFragment instance
* @api private
*/
3566
function parse(html, doc) {
 if ('string' != typeof html) throw new TypeError('String expected');
3569
 // default to the global `document` object
 if (!doc) doc = document;
3572
 // tag name
 var m = /<([\w:]+)/.exec(html);
 if (!m) return doc.createTextNode(html);
3576
 html = html.replace(/^\s+|\s+$/g, ''); // Remove leading/trailing whitespace
3578
 var tag = m[1];
3580
 // body support
 if (tag == 'body') {
   var el = doc.createElement('html');
   el.innerHTML = html;
   return el.removeChild(el.lastChild);
 }
3587
 // wrap map
 var wrap = map$1[tag] || map$1._default;
 var depth = wrap[0];
 var prefix = wrap[1];
 var suffix = wrap[2];
 var el = doc.createElement('div');
 el.innerHTML = prefix + html + suffix;
 while (depth--) el = el.lastChild;
3596
 // one element
 if (el.firstChild == el.lastChild) {
   return el.removeChild(el.firstChild);
 }
3601
 // several elements
 var fragment = doc.createDocumentFragment();
 while (el.firstChild) {
   fragment.appendChild(el.removeChild(el.firstChild));
 }
3607
 return fragment;
}
3610
function query(selector, el) {
 el = el || document;
3613
 return el.querySelector(selector);
}
3616
function all(selector, el) {
 el = el || document;
3619
 return el.querySelectorAll(selector);
}
3622
function remove$1(el) {
 el.parentNode && el.parentNode.removeChild(el);
}
3626
/**
* Failsafe remove an element from a collection
*
* @param  {Array<Object>} [collection]
* @param  {Object} [element]
*
* @return {number} the previous index of the element
*/
function remove(collection, element) {
3636
 if (!collection || !element) {
   return -1;
 }
3640
 var idx = collection.indexOf(element);
3642
 if (idx !== -1) {
   collection.splice(idx, 1);
 }
3646
 return idx;
}
3649
/**
* Fail save add an element to the given connection, ensuring
* it does not yet exist.
*
* @param {Array<Object>} collection
* @param {Object} element
* @param {number} idx
*/
function add(collection, element, idx) {
3659
 if (!collection || !element) {
   return;
 }
3663
 if (typeof idx !== 'number') {
   idx = -1;
 }
3667
 var currentIdx = collection.indexOf(element);
3669
 if (currentIdx !== -1) {
3671
   if (currentIdx === idx) {
3673
     // nothing to do, position has not changed
     return;
   } else {
3677
     if (idx !== -1) {
3679
       // remove from current position
       collection.splice(currentIdx, 1);
     } else {
3683
       // already exists in collection
       return;
     }
   }
 }
3689
 if (idx !== -1) {
3691
   // insert at specified position
   collection.splice(idx, 0, element);
 } else {
3695
   // push to end
   collection.push(element);
 }
}
3700
3701
/**
* Fail save get the index of an element in a collection.
*
* @param {Array<Object>} collection
* @param {Object} element
*
* @return {number} the index or -1 if collection or element do
*                  not exist or the element is not contained.
*/
function indexOf(collection, element) {
3712
 if (!collection || !element) {
   return -1;
 }
3716
 return collection.indexOf(element);
}
3719
/**
* Computes the distance between two points
*
* @param  {Point}  p
* @param  {Point}  q
*
* @return {number}  distance
*/
function pointDistance(a, b) {
 if (!a || !b) {
   return -1;
 }
3732
 return Math.sqrt(
   Math.pow(a.x - b.x, 2) +
   Math.pow(a.y - b.y, 2)
 );
}
3738
3739
/**
* Returns true if the point r is on the line between p and q
*
* @param  {Point}  p
* @param  {Point}  q
* @param  {Point}  r
* @param  {number} [accuracy=5] accuracy for points on line check (lower is better)
*
* @return {boolean}
*/
function pointsOnLine(p, q, r, accuracy) {
3751
 if (typeof accuracy === 'undefined') {
   accuracy = 5;
 }
3755
 if (!p || !q || !r) {
   return false;
 }
3759
 var val = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x),
     dist = pointDistance(p, q);
3762
 // @see http://stackoverflow.com/a/907491/412190
 return Math.abs(val / dist) <= accuracy;
}
3766
3767
var ALIGNED_THRESHOLD = 2;
3769
/**
* Check whether two points are horizontally or vertically aligned.
*
* @param {Array<Point>|Point}
* @param {Point}
*
* @return {string|boolean}
*/
function pointsAligned(a, b) {
 var points;
3780
 if (isArray$4(a)) {
   points = a;
 } else {
   points = [ a, b ];
 }
3786
 if (pointsAlignedHorizontally(points)) {
   return 'h';
 }
3790
 if (pointsAlignedVertically(points)) {
   return 'v';
 }
3794
 return false;
}
3797
function pointsAlignedHorizontally(a, b) {
 var points;
3800
 if (isArray$4(a)) {
   points = a;
 } else {
   points = [ a, b ];
 }
3806
 var firstPoint = points.slice().shift();
3808
 return every(points, function(point) {
   return Math.abs(firstPoint.y - point.y) <= ALIGNED_THRESHOLD;
 });
}
3813
function pointsAlignedVertically(a, b) {
 var points;
3816
 if (isArray$4(a)) {
   points = a;
 } else {
   points = [ a, b ];
 }
3822
 var firstPoint = points.slice().shift();
3824
 return every(points, function(point) {
   return Math.abs(firstPoint.x - point.x) <= ALIGNED_THRESHOLD;
 });
}
3829
3830
3831
/**
* Returns true if the point p is inside the rectangle rect
*
* @param  {Point}  p
* @param  {Rect} rect
* @param  {number} tolerance
*
* @return {boolean}
*/
function pointInRect(p, rect, tolerance) {
 tolerance = tolerance || 0;
3843
 return p.x > rect.x - tolerance &&
        p.y > rect.y - tolerance &&
        p.x < rect.x + rect.width + tolerance &&
        p.y < rect.y + rect.height + tolerance;
}
3849
/**
* Returns a point in the middle of points p and q
*
* @param  {Point}  p
* @param  {Point}  q
*
* @return {Point} middle point
*/
function getMidPoint(p, q) {
 return {
   x: Math.round(p.x + ((q.x - p.x) / 2.0)),
   y: Math.round(p.y + ((q.y - p.y) / 2.0))
 };
}
3864
/**
* This file contains source code adapted from Snap.svg (licensed Apache-2.0).
*
* @see https://github.com/adobe-webplatform/Snap.svg/blob/master/src/path.js
*/
3870
/* eslint no-fallthrough: "off" */
3872
var p2s = /,?([a-z]),?/gi,
   toFloat = parseFloat,
   math = Math,
   PI = math.PI,
   mmin = math.min,
   mmax = math.max,
   pow = math.pow,
   abs$7 = math.abs,
   pathCommand = /([a-z])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?[\s]*,?[\s]*)+)/ig,
   pathValues = /(-?\d*\.?\d*(?:e[-+]?\d+)?)[\s]*,?[\s]*/ig;
3883
var isArray = Array.isArray || function(o) { return o instanceof Array; };
3885
function hasProperty(obj, property) {
 return Object.prototype.hasOwnProperty.call(obj, property);
}
3889
function clone(obj) {
3891
 if (typeof obj == 'function' || Object(obj) !== obj) {
   return obj;
 }
3895
 var res = new obj.constructor;
3897
 for (var key in obj) {
   if (hasProperty(obj, key)) {
     res[key] = clone(obj[key]);
   }
 }
3903
 return res;
}
3906
function repush(array, item) {
 for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) {
   return array.push(array.splice(i, 1)[0]);
 }
}
3912
function cacher(f) {
3914
 function newf() {
3916
   var arg = Array.prototype.slice.call(arguments, 0),
       args = arg.join('\u2400'),
       cache = newf.cache = newf.cache || {},
       count = newf.count = newf.count || [];
3921
   if (hasProperty(cache, args)) {
     repush(count, args);
     return cache[args];
   }
3926
   count.length >= 1e3 && delete cache[count.shift()];
   count.push(args);
   cache[args] = f.apply(0, arg);
3930
   return cache[args];
 }
 return newf;
}
3935
function parsePathString(pathString) {
3937
 if (!pathString) {
   return null;
 }
3941
 var pth = paths(pathString);
3943
 if (pth.arr) {
   return clone(pth.arr);
 }
3947
 var paramCounts = { a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0 },
     data = [];
3950
 if (isArray(pathString) && isArray(pathString[0])) { // rough assumption
   data = clone(pathString);
 }
3954
 if (!data.length) {
3956
   String(pathString).replace(pathCommand, function(a, b, c) {
     var params = [],
         name = b.toLowerCase();
3960
     c.replace(pathValues, function(a, b) {
       b && params.push(+b);
     });
3964
     if (name == 'm' && params.length > 2) {
       data.push([b].concat(params.splice(0, 2)));
       name = 'l';
       b = b == 'm' ? 'l' : 'L';
     }
3970
     while (params.length >= paramCounts[name]) {
       data.push([b].concat(params.splice(0, paramCounts[name])));
       if (!paramCounts[name]) {
         break;
       }
     }
   });
 }
3979
 data.toString = paths.toString;
 pth.arr = clone(data);
3982
 return data;
}
3985
function paths(ps) {
 var p = paths.ps = paths.ps || {};
3988
 if (p[ps]) {
   p[ps].sleep = 100;
 } else {
   p[ps] = {
     sleep: 100
   };
 }
3996
 setTimeout(function() {
   for (var key in p) {
     if (hasProperty(p, key) && key != ps) {
       p[key].sleep--;
       !p[key].sleep && delete p[key];
     }
   }
 });
4005
 return p[ps];
}
4008
function rectBBox(x, y, width, height) {
4010
 if (arguments.length === 1) {
   y = x.y;
   width = x.width;
   height = x.height;
   x = x.x;
 }
4017
 return {
   x: x,
   y: y,
   width: width,
   height: height,
   x2: x + width,
   y2: y + height
 };
}
4027
function pathToString() {
 return this.join(',').replace(p2s, '$1');
}
4031
function pathClone(pathArray) {
 var res = clone(pathArray);
 res.toString = pathToString;
 return res;
}
4037
function findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
 var t1 = 1 - t,
     t13 = pow(t1, 3),
     t12 = pow(t1, 2),
     t2 = t * t,
     t3 = t2 * t,
     x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,
     y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y;
4046
 return {
   x: fixError(x),
   y: fixError(y)
 };
}
4052
function bezierBBox(points) {
4054
 var bbox = curveBBox.apply(null, points);
4056
 return rectBBox(
   bbox.x0,
   bbox.y0,
   bbox.x1 - bbox.x0,
   bbox.y1 - bbox.y0
 );
}
4064
function isPointInsideBBox$2(bbox, x, y) {
 return x >= bbox.x &&
   x <= bbox.x + bbox.width &&
   y >= bbox.y &&
   y <= bbox.y + bbox.height;
}
4071
function isBBoxIntersect(bbox1, bbox2) {
 bbox1 = rectBBox(bbox1);
 bbox2 = rectBBox(bbox2);
 return isPointInsideBBox$2(bbox2, bbox1.x, bbox1.y)
   || isPointInsideBBox$2(bbox2, bbox1.x2, bbox1.y)
   || isPointInsideBBox$2(bbox2, bbox1.x, bbox1.y2)
   || isPointInsideBBox$2(bbox2, bbox1.x2, bbox1.y2)
   || isPointInsideBBox$2(bbox1, bbox2.x, bbox2.y)
   || isPointInsideBBox$2(bbox1, bbox2.x2, bbox2.y)
   || isPointInsideBBox$2(bbox1, bbox2.x, bbox2.y2)
   || isPointInsideBBox$2(bbox1, bbox2.x2, bbox2.y2)
   || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x
       || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)
   && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y
       || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);
}
4088
function base3(t, p1, p2, p3, p4) {
 var t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4,
     t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;
 return t * t2 - 3 * p1 + 3 * p2;
}
4094
function bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {
4096
 if (z == null) {
   z = 1;
 }
4100
 z = z > 1 ? 1 : z < 0 ? 0 : z;
4102
 var z2 = z / 2,
     n = 12,
     Tvalues = [-.1252,.1252,-.3678,.3678,-.5873,.5873,-.7699,.7699,-.9041,.9041,-.9816,.9816],
     Cvalues = [0.2491,0.2491,0.2335,0.2335,0.2032,0.2032,0.1601,0.1601,0.1069,0.1069,0.0472,0.0472],
     sum = 0;
4108
 for (var i = 0; i < n; i++) {
   var ct = z2 * Tvalues[i] + z2,
       xbase = base3(ct, x1, x2, x3, x4),
       ybase = base3(ct, y1, y2, y3, y4),
       comb = xbase * xbase + ybase * ybase;
4114
   sum += Cvalues[i] * math.sqrt(comb);
 }
4117
 return z2 * sum;
}
4120
4121
function intersectLines(x1, y1, x2, y2, x3, y3, x4, y4) {
4123
 if (
   mmax(x1, x2) < mmin(x3, x4) ||
     mmin(x1, x2) > mmax(x3, x4) ||
     mmax(y1, y2) < mmin(y3, y4) ||
     mmin(y1, y2) > mmax(y3, y4)
 ) {
   return;
 }
4132
 var nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),
     ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),
     denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
4136
 if (!denominator) {
   return;
 }
4140
 var px = fixError(nx / denominator),
     py = fixError(ny / denominator),
     px2 = +px.toFixed(2),
     py2 = +py.toFixed(2);
4145
 if (
   px2 < +mmin(x1, x2).toFixed(2) ||
     px2 > +mmax(x1, x2).toFixed(2) ||
     px2 < +mmin(x3, x4).toFixed(2) ||
     px2 > +mmax(x3, x4).toFixed(2) ||
     py2 < +mmin(y1, y2).toFixed(2) ||
     py2 > +mmax(y1, y2).toFixed(2) ||
     py2 < +mmin(y3, y4).toFixed(2) ||
     py2 > +mmax(y3, y4).toFixed(2)
 ) {
   return;
 }
4158
 return { x: px, y: py };
}
4161
function fixError(number) {
 return Math.round(number * 100000000000) / 100000000000;
}
4165
function findBezierIntersections(bez1, bez2, justCount) {
 var bbox1 = bezierBBox(bez1),
     bbox2 = bezierBBox(bez2);
4169
 if (!isBBoxIntersect(bbox1, bbox2)) {
   return justCount ? 0 : [];
 }
4173
 // As an optimization, lines will have only 1 segment
4175
 var l1 = bezlen.apply(0, bez1),
     l2 = bezlen.apply(0, bez2),
     n1 = isLine(bez1) ? 1 : ~~(l1 / 5) || 1,
     n2 = isLine(bez2) ? 1 : ~~(l2 / 5) || 1,
     dots1 = [],
     dots2 = [],
     xy = {},
     res = justCount ? 0 : [];
4184
 for (var i = 0; i < n1 + 1; i++) {
   var p = findDotsAtSegment.apply(0, bez1.concat(i / n1));
   dots1.push({ x: p.x, y: p.y, t: i / n1 });
 }
4189
 for (i = 0; i < n2 + 1; i++) {
   p = findDotsAtSegment.apply(0, bez2.concat(i / n2));
   dots2.push({ x: p.x, y: p.y, t: i / n2 });
 }
4194
 for (i = 0; i < n1; i++) {
4196
   for (var j = 0; j < n2; j++) {
     var di = dots1[i],
         di1 = dots1[i + 1],
         dj = dots2[j],
         dj1 = dots2[j + 1],
         ci = abs$7(di1.x - di.x) < .01 ? 'y' : 'x',
         cj = abs$7(dj1.x - dj.x) < .01 ? 'y' : 'x',
         is = intersectLines(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y),
         key;
4206
     if (is) {
       key = is.x.toFixed(9) + '#' + is.y.toFixed(9);
4209
       if (xy[key]) {
         continue;
       }
4213
       xy[key] = true;
4215
       var t1 = di.t + abs$7((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),
           t2 = dj.t + abs$7((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);
4218
       if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {
4220
         if (justCount) {
           res++;
         } else {
           res.push({
             x: is.x,
             y: is.y,
             t1: t1,
             t2: t2
           });
         }
       }
     }
   }
 }
4235
 return res;
}
4238
4239
/**
* Find or counts the intersections between two SVG paths.
*
* Returns a number in counting mode and a list of intersections otherwise.
*
* A single intersection entry contains the intersection coordinates (x, y)
* as well as additional information regarding the intersecting segments
* on each path (segment1, segment2) and the relative location of the
* intersection on these segments (t1, t2).
*
* The path may be an SVG path string or a list of path components
* such as `[ [ 'M', 0, 10 ], [ 'L', 20, 0 ] ]`.
*
* @example
*
* var intersections = findPathIntersections(
*   'M0,0L100,100',
*   [ [ 'M', 0, 100 ], [ 'L', 100, 0 ] ]
* );
*
* // intersections = [
* //   { x: 50, y: 50, segment1: 1, segment2: 1, t1: 0.5, t2: 0.5 }
* // ]
*
* @param {String|Array<PathDef>} path1
* @param {String|Array<PathDef>} path2
* @param {Boolean} [justCount=false]
*
* @return {Array<Intersection>|Number}
*/
function findPathIntersections(path1, path2, justCount) {
 path1 = pathToCurve(path1);
 path2 = pathToCurve(path2);
4273
 var x1, y1, x2, y2, x1m, y1m, x2m, y2m, bez1, bez2,
     res = justCount ? 0 : [];
4276
 for (var i = 0, ii = path1.length; i < ii; i++) {
   var pi = path1[i];
4279
   if (pi[0] == 'M') {
     x1 = x1m = pi[1];
     y1 = y1m = pi[2];
   } else {
4284
     if (pi[0] == 'C') {
       bez1 = [x1, y1].concat(pi.slice(1));
       x1 = bez1[6];
       y1 = bez1[7];
     } else {
       bez1 = [x1, y1, x1, y1, x1m, y1m, x1m, y1m];
       x1 = x1m;
       y1 = y1m;
     }
4294
     for (var j = 0, jj = path2.length; j < jj; j++) {
       var pj = path2[j];
4297
       if (pj[0] == 'M') {
         x2 = x2m = pj[1];
         y2 = y2m = pj[2];
       } else {
4302
         if (pj[0] == 'C') {
           bez2 = [x2, y2].concat(pj.slice(1));
           x2 = bez2[6];
           y2 = bez2[7];
         } else {
           bez2 = [x2, y2, x2, y2, x2m, y2m, x2m, y2m];
           x2 = x2m;
           y2 = y2m;
         }
4312
         var intr = findBezierIntersections(bez1, bez2, justCount);
4314
         if (justCount) {
           res += intr;
         } else {
4318
           for (var k = 0, kk = intr.length; k < kk; k++) {
             intr[k].segment1 = i;
             intr[k].segment2 = j;
             intr[k].bez1 = bez1;
             intr[k].bez2 = bez2;
           }
4325
           res = res.concat(intr);
         }
       }
     }
   }
 }
4332
 return res;
}
4335
4336
function pathToAbsolute(pathArray) {
 var pth = paths(pathArray);
4339
 if (pth.abs) {
   return pathClone(pth.abs);
 }
4343
 if (!isArray(pathArray) || !isArray(pathArray && pathArray[0])) { // rough assumption
   pathArray = parsePathString(pathArray);
 }
4347
 if (!pathArray || !pathArray.length) {
   return [['M', 0, 0]];
 }
4351
 var res = [],
     x = 0,
     y = 0,
     mx = 0,
     my = 0,
     start = 0,
     pa0;
4359
 if (pathArray[0][0] == 'M') {
   x = +pathArray[0][1];
   y = +pathArray[0][2];
   mx = x;
   my = y;
   start++;
   res[0] = ['M', x, y];
 }
4368
 for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) {
   res.push(r = []);
   pa = pathArray[i];
   pa0 = pa[0];
4373
   if (pa0 != pa0.toUpperCase()) {
     r[0] = pa0.toUpperCase();
4376
     switch (r[0]) {
     case 'A':
       r[1] = pa[1];
       r[2] = pa[2];
       r[3] = pa[3];
       r[4] = pa[4];
       r[5] = pa[5];
       r[6] = +pa[6] + x;
       r[7] = +pa[7] + y;
       break;
     case 'V':
       r[1] = +pa[1] + y;
       break;
     case 'H':
       r[1] = +pa[1] + x;
       break;
     case 'M':
       mx = +pa[1] + x;
       my = +pa[2] + y;
     default:
       for (var j = 1, jj = pa.length; j < jj; j++) {
         r[j] = +pa[j] + ((j % 2) ? x : y);
       }
     }
   } else {
     for (var k = 0, kk = pa.length; k < kk; k++) {
       r[k] = pa[k];
     }
   }
   pa0 = pa0.toUpperCase();
4407
   switch (r[0]) {
   case 'Z':
     x = +mx;
     y = +my;
     break;
   case 'H':
     x = r[1];
     break;
   case 'V':
     y = r[1];
     break;
   case 'M':
     mx = r[r.length - 2];
     my = r[r.length - 1];
   default:
     x = r[r.length - 2];
     y = r[r.length - 1];
   }
 }
4427
 res.toString = pathToString;
 pth.abs = pathClone(res);
4430
 return res;
}
4433
function isLine(bez) {
 return (
   bez[0] === bez[2] &&
   bez[1] === bez[3] &&
   bez[4] === bez[6] &&
   bez[5] === bez[7]
 );
}
4442
function lineToCurve(x1, y1, x2, y2) {
 return [
   x1, y1, x2,
   y2, x2, y2
 ];
}
4449
function qubicToCurve(x1, y1, ax, ay, x2, y2) {
 var _13 = 1 / 3,
     _23 = 2 / 3;
4453
 return [
   _13 * x1 + _23 * ax,
   _13 * y1 + _23 * ay,
   _13 * x2 + _23 * ax,
   _13 * y2 + _23 * ay,
   x2,
   y2
 ];
}
4463
function arcToCurve(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
4465
 // for more information of where this math came from visit:
 // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
 var _120 = PI * 120 / 180,
     rad = PI / 180 * (+angle || 0),
     res = [],
     xy,
     rotate = cacher(function(x, y, rad) {
       var X = x * math.cos(rad) - y * math.sin(rad),
           Y = x * math.sin(rad) + y * math.cos(rad);
4475
       return { x: X, y: Y };
     });
4478
 if (!recursive) {
   xy = rotate(x1, y1, -rad);
   x1 = xy.x;
   y1 = xy.y;
   xy = rotate(x2, y2, -rad);
   x2 = xy.x;
   y2 = xy.y;
4486
   var x = (x1 - x2) / 2,
       y = (y1 - y2) / 2;
4489
   var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
4491
   if (h > 1) {
     h = math.sqrt(h);
     rx = h * rx;
     ry = h * ry;
   }
4497
   var rx2 = rx * rx,
       ry2 = ry * ry,
       k = (large_arc_flag == sweep_flag ? -1 : 1) *
           math.sqrt(abs$7((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
       cx = k * rx * y / ry + (x1 + x2) / 2,
       cy = k * -ry * x / rx + (y1 + y2) / 2,
       f1 = math.asin(((y1 - cy) / ry).toFixed(9)),
       f2 = math.asin(((y2 - cy) / ry).toFixed(9));
4506
   f1 = x1 < cx ? PI - f1 : f1;
   f2 = x2 < cx ? PI - f2 : f2;
   f1 < 0 && (f1 = PI * 2 + f1);
   f2 < 0 && (f2 = PI * 2 + f2);
4511
   if (sweep_flag && f1 > f2) {
     f1 = f1 - PI * 2;
   }
   if (!sweep_flag && f2 > f1) {
     f2 = f2 - PI * 2;
   }
 } else {
   f1 = recursive[0];
   f2 = recursive[1];
   cx = recursive[2];
   cy = recursive[3];
 }
4524
 var df = f2 - f1;
4526
 if (abs$7(df) > _120) {
   var f2old = f2,
       x2old = x2,
       y2old = y2;
4531
   f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
   x2 = cx + rx * math.cos(f2);
   y2 = cy + ry * math.sin(f2);
   res = arcToCurve(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
 }
4537
 df = f2 - f1;
4539
 var c1 = math.cos(f1),
     s1 = math.sin(f1),
     c2 = math.cos(f2),
     s2 = math.sin(f2),
     t = math.tan(df / 4),
     hx = 4 / 3 * rx * t,
     hy = 4 / 3 * ry * t,
     m1 = [x1, y1],
     m2 = [x1 + hx * s1, y1 - hy * c1],
     m3 = [x2 + hx * s2, y2 - hy * c2],
     m4 = [x2, y2];
4551
 m2[0] = 2 * m1[0] - m2[0];
 m2[1] = 2 * m1[1] - m2[1];
4554
 if (recursive) {
   return [m2, m3, m4].concat(res);
 } else {
   res = [m2, m3, m4].concat(res).join().split(',');
   var newres = [];
4560
   for (var i = 0, ii = res.length; i < ii; i++) {
     newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
   }
4564
   return newres;
 }
}
4568
// Returns bounding box of cubic bezier curve.
// Source: http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html
// Original version: NISHIO Hirokazu
// Modifications: https://github.com/timo22345
function curveBBox(x0, y0, x1, y1, x2, y2, x3, y3) {
 var tvalues = [],
     bounds = [[], []],
     a, b, c, t, t1, t2, b2ac, sqrtb2ac;
4577
 for (var i = 0; i < 2; ++i) {
4579
   if (i == 0) {
     b = 6 * x0 - 12 * x1 + 6 * x2;
     a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
     c = 3 * x1 - 3 * x0;
   } else {
     b = 6 * y0 - 12 * y1 + 6 * y2;
     a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
     c = 3 * y1 - 3 * y0;
   }
4589
   if (abs$7(a) < 1e-12) {
4591
     if (abs$7(b) < 1e-12) {
       continue;
     }
4595
     t = -c / b;
4597
     if (0 < t && t < 1) {
       tvalues.push(t);
     }
4601
     continue;
   }
4604
   b2ac = b * b - 4 * c * a;
   sqrtb2ac = math.sqrt(b2ac);
4607
   if (b2ac < 0) {
     continue;
   }
4611
   t1 = (-b + sqrtb2ac) / (2 * a);
4613
   if (0 < t1 && t1 < 1) {
     tvalues.push(t1);
   }
4617
   t2 = (-b - sqrtb2ac) / (2 * a);
4619
   if (0 < t2 && t2 < 1) {
     tvalues.push(t2);
   }
 }
4624
 var j = tvalues.length,
     jlen = j,
     mt;
4628
 while (j--) {
   t = tvalues[j];
   mt = 1 - t;
   bounds[0][j] = (mt * mt * mt * x0) + (3 * mt * mt * t * x1) + (3 * mt * t * t * x2) + (t * t * t * x3);
   bounds[1][j] = (mt * mt * mt * y0) + (3 * mt * mt * t * y1) + (3 * mt * t * t * y2) + (t * t * t * y3);
 }
4635
 bounds[0][jlen] = x0;
 bounds[1][jlen] = y0;
 bounds[0][jlen + 1] = x3;
 bounds[1][jlen + 1] = y3;
 bounds[0].length = bounds[1].length = jlen + 2;
4641
 return {
   x0: mmin.apply(0, bounds[0]),
   y0: mmin.apply(0, bounds[1]),
   x1: mmax.apply(0, bounds[0]),
   y1: mmax.apply(0, bounds[1])
 };
}
4649
function pathToCurve(path) {
4651
 var pth = paths(path);
4653
 // return cached curve, if existing
 if (pth.curve) {
   return pathClone(pth.curve);
 }
4658
 var curvedPath = pathToAbsolute(path),
     attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },
     processPath = function(path, d, pathCommand) {
       var nx, ny;
4663
       if (!path) {
         return ['C', d.x, d.y, d.x, d.y, d.x, d.y];
       }
4667
       !(path[0] in { T: 1, Q: 1 }) && (d.qx = d.qy = null);
4669
       switch (path[0]) {
       case 'M':
         d.X = path[1];
         d.Y = path[2];
         break;
       case 'A':
         path = ['C'].concat(arcToCurve.apply(0, [d.x, d.y].concat(path.slice(1))));
         break;
       case 'S':
         if (pathCommand == 'C' || pathCommand == 'S') {
4680
           // In 'S' case we have to take into account, if the previous command is C/S.
           nx = d.x * 2 - d.bx;
4683
           // And reflect the previous
           ny = d.y * 2 - d.by;
4686
           // command's control point relative to the current point.
         }
         else {
4690
           // or some else or nothing
           nx = d.x;
           ny = d.y;
         }
         path = ['C', nx, ny].concat(path.slice(1));
         break;
       case 'T':
         if (pathCommand == 'Q' || pathCommand == 'T') {
4699
           // In 'T' case we have to take into account, if the previous command is Q/T.
           d.qx = d.x * 2 - d.qx;
4702
           // And make a reflection similar
           d.qy = d.y * 2 - d.qy;
4705
           // to case 'S'.
         }
         else {
4709
           // or something else or nothing
           d.qx = d.x;
           d.qy = d.y;
         }
         path = ['C'].concat(qubicToCurve(d.x, d.y, d.qx, d.qy, path[1], path[2]));
         break;
       case 'Q':
         d.qx = path[1];
         d.qy = path[2];
         path = ['C'].concat(qubicToCurve(d.x, d.y, path[1], path[2], path[3], path[4]));
         break;
       case 'L':
         path = ['C'].concat(lineToCurve(d.x, d.y, path[1], path[2]));
         break;
       case 'H':
         path = ['C'].concat(lineToCurve(d.x, d.y, path[1], d.y));
         break;
       case 'V':
         path = ['C'].concat(lineToCurve(d.x, d.y, d.x, path[1]));
         break;
       case 'Z':
         path = ['C'].concat(lineToCurve(d.x, d.y, d.X, d.Y));
         break;
       }
4734
       return path;
     },
4737
     fixArc = function(pp, i) {
4739
       if (pp[i].length > 7) {
         pp[i].shift();
         var pi = pp[i];
4743
         while (pi.length) {
           pathCommands[i] = 'A'; // if created multiple C:s, their original seg is saved
           pp.splice(i++, 0, ['C'].concat(pi.splice(0, 6)));
         }
4748
         pp.splice(i, 1);
         ii = curvedPath.length;
       }
     },
4753
     pathCommands = [], // path commands of original path p
     pfirst = '', // temporary holder for original path command
     pathCommand = ''; // holder for previous path command of original path
4757
 for (var i = 0, ii = curvedPath.length; i < ii; i++) {
   curvedPath[i] && (pfirst = curvedPath[i][0]); // save current path command
4760
   if (pfirst != 'C') // C is not saved yet, because it may be result of conversion
   {
     pathCommands[i] = pfirst; // Save current path command
     i && (pathCommand = pathCommands[i - 1]); // Get previous path command pathCommand
   }
   curvedPath[i] = processPath(curvedPath[i], attrs, pathCommand); // Previous path command is inputted to processPath
4767
   if (pathCommands[i] != 'A' && pfirst == 'C') pathCommands[i] = 'C'; // A is the only command
   // which may produce multiple C:s
   // so we have to make sure that C is also C in original path
4771
   fixArc(curvedPath, i); // fixArc adds also the right amount of A:s to pathCommands
4773
   var seg = curvedPath[i],
       seglen = seg.length;
4776
   attrs.x = seg[seglen - 2];
   attrs.y = seg[seglen - 1];
   attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;
   attrs.by = toFloat(seg[seglen - 3]) || attrs.y;
 }
4782
 // cache curve
 pth.curve = pathClone(curvedPath);
4785
 return curvedPath;
}
4788
var intersect = findPathIntersections;
4790
function roundBounds(bounds) {
 return {
   x: Math.round(bounds.x),
   y: Math.round(bounds.y),
   width: Math.round(bounds.width),
   height: Math.round(bounds.height)
 };
}
4799
4800
function roundPoint(point) {
4802
 return {
   x: Math.round(point.x),
   y: Math.round(point.y)
 };
}
4808
4809
/**
* Convert the given bounds to a { top, left, bottom, right } descriptor.
*
* @param {Bounds|Point} bounds
*
* @return {Object}
*/
function asTRBL(bounds) {
 return {
   top: bounds.y,
   right: bounds.x + (bounds.width || 0),
   bottom: bounds.y + (bounds.height || 0),
   left: bounds.x
 };
}
4825
4826
/**
* Convert a { top, left, bottom, right } to an objects bounds.
*
* @param {Object} trbl
*
* @return {Bounds}
*/
function asBounds(trbl) {
 return {
   x: trbl.left,
   y: trbl.top,
   width: trbl.right - trbl.left,
   height: trbl.bottom - trbl.top
 };
}
4842
4843
/**
* Get the mid of the given bounds or point.
*
* @param {Bounds|Point} bounds
*
* @return {Point}
*/
function getMid(bounds) {
 return roundPoint({
   x: bounds.x + (bounds.width || 0) / 2,
   y: bounds.y + (bounds.height || 0) / 2
 });
}
4857
4858
// orientation utils //////////////////////
4860
/**
* Get orientation of the given rectangle with respect to
* the reference rectangle.
*
* A padding (positive or negative) may be passed to influence
* horizontal / vertical orientation and intersection.
*
* @param {Bounds} rect
* @param {Bounds} reference
* @param {Point|number} padding
*
* @return {string} the orientation; one of top, top-left, left, ..., bottom, right or intersect.
*/
function getOrientation(rect, reference, padding) {
4875
 padding = padding || 0;
4877
 // make sure we can use an object, too
 // for individual { x, y } padding
 if (!isObject(padding)) {
   padding = { x: padding, y: padding };
 }
4883
4884
 var rectOrientation = asTRBL(rect),
     referenceOrientation = asTRBL(reference);
4887
 var top = rectOrientation.bottom + padding.y <= referenceOrientation.top,
     right = rectOrientation.left - padding.x >= referenceOrientation.right,
     bottom = rectOrientation.top - padding.y >= referenceOrientation.bottom,
     left = rectOrientation.right + padding.x <= referenceOrientation.left;
4892
 var vertical = top ? 'top' : (bottom ? 'bottom' : null),
     horizontal = left ? 'left' : (right ? 'right' : null);
4895
 if (horizontal && vertical) {
   return vertical + '-' + horizontal;
 } else {
   return horizontal || vertical || 'intersect';
 }
}
4902
4903
// intersection utils //////////////////////
4905
/**
* Get intersection between an element and a line path.
*
* @param {PathDef} elementPath
* @param {PathDef} linePath
* @param {boolean} cropStart crop from start or end
*
* @return {Point}
*/
function getElementLineIntersection(elementPath, linePath, cropStart) {
4916
 var intersections = getIntersections(elementPath, linePath);
4918
 // recognize intersections
 // only one -> choose
 // two close together -> choose first
 // two or more distinct -> pull out appropriate one
 // none -> ok (fallback to point itself)
 if (intersections.length === 1) {
   return roundPoint(intersections[0]);
 } else if (intersections.length === 2 && pointDistance(intersections[0], intersections[1]) < 1) {
   return roundPoint(intersections[0]);
 } else if (intersections.length > 1) {
4929
   // sort by intersections based on connection segment +
   // distance from start
   intersections = sortBy(intersections, function(i) {
     var distance = Math.floor(i.t2 * 100) || 1;
4934
     distance = 100 - distance;
4936
     distance = (distance < 10 ? '0' : '') + distance;
4938
     // create a sort string that makes sure we sort
     // line segment ASC + line segment position DESC (for cropStart)
     // line segment ASC + line segment position ASC (for cropEnd)
     return i.segment2 + '#' + distance;
   });
4944
   return roundPoint(intersections[cropStart ? 0 : intersections.length - 1]);
 }
4947
 return null;
}
4950
4951
function getIntersections(a, b) {
 return intersect(a, b);
}
4955
4956
function filterRedundantWaypoints(waypoints) {
4958
 // alter copy of waypoints, not original
 waypoints = waypoints.slice();
4961
 var idx = 0,
     point,
     previousPoint,
     nextPoint;
4966
 while (waypoints[idx]) {
   point = waypoints[idx];
   previousPoint = waypoints[idx - 1];
   nextPoint = waypoints[idx + 1];
4971
   if (pointDistance(point, nextPoint) === 0 ||
       pointsOnLine(previousPoint, nextPoint, point)) {
4974
     // remove point, if overlapping with {nextPoint}
     // or on line with {previousPoint} -> {point} -> {nextPoint}
     waypoints.splice(idx, 1);
   } else {
     idx++;
   }
 }
4982
 return waypoints;
}
4985
function round$b(number, resolution) {
 return Math.round(number * resolution) / resolution;
}
4989
function ensurePx(number) {
 return isNumber(number) ? number + 'px' : number;
}
4993
function findRoot(element) {
 while (element.parent) {
   element = element.parent;
 }
4998
 return element;
}
5001
/**
* Creates a HTML container element for a SVG element with
* the given configuration
*
* @param  {Object} options
* @return {HTMLElement} the container element
*/
function createContainer(options) {
5010
 options = assign({}, { width: '100%', height: '100%' }, options);
5012
 var container = options.container || document.body;
5014
 // create a <div> around the svg element with the respective size
 // this way we can always get the correct container size
 // (this is impossible for <svg> elements at the moment)
 var parent = document.createElement('div');
 parent.setAttribute('class', 'djs-container');
5020
 assign$1(parent, {
   position: 'relative',
   overflow: 'hidden',
   width: ensurePx(options.width),
   height: ensurePx(options.height)
 });
5027
 container.appendChild(parent);
5029
 return parent;
}
5032
function createGroup(parent, cls, childIndex) {
 var group = create$1('g');
 classes$1(group).add(cls);
5036
 var index = childIndex !== undefined ? childIndex : parent.childNodes.length - 1;
5038
 // must ensure second argument is node or _null_
 // cf. https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore
 parent.insertBefore(group, parent.childNodes[index] || null);
5042
 return group;
}
5045
var BASE_LAYER = 'base';
5047
// render plane contents behind utility layers
var PLANE_LAYER_INDEX = 0;
var UTILITY_LAYER_INDEX = 1;
5051
5052
var REQUIRED_MODEL_ATTRS = {
 shape: [ 'x', 'y', 'width', 'height' ],
 connection: [ 'waypoints' ]
};
5057
/**
* The main drawing canvas.
*
* @class
* @constructor
*
* @emits Canvas#canvas.init
*
* @param {Object} config
* @param {EventBus} eventBus
* @param {GraphicsFactory} graphicsFactory
* @param {ElementRegistry} elementRegistry
*/
function Canvas(config, eventBus, graphicsFactory, elementRegistry) {
5072
 this._eventBus = eventBus;
 this._elementRegistry = elementRegistry;
 this._graphicsFactory = graphicsFactory;
5076
 this._rootsIdx = 0;
5078
 this._layers = {};
 this._planes = [];
 this._rootElement = null;
5082
 this._init(config || {});
}
5085
Canvas.$inject = [
 'config.canvas',
 'eventBus',
 'graphicsFactory',
 'elementRegistry'
];
5092
/**
* Creates a <svg> element that is wrapped into a <div>.
* This way we are always able to correctly figure out the size of the svg element
* by querying the parent node.
5097
* (It is not possible to get the size of a svg element cross browser @ 2014-04-01)
5099
* <div class="djs-container" style="width: {desired-width}, height: {desired-height}">
*   <svg width="100%" height="100%">
*    ...
*   </svg>
* </div>
*/
Canvas.prototype._init = function(config) {
5107
 var eventBus = this._eventBus;
5109
 // html container
 var container = this._container = createContainer(config);
5112
 var svg = this._svg = create$1('svg');
 attr$1(svg, { width: '100%', height: '100%' });
5115
 append(container, svg);
5117
 var viewport = this._viewport = createGroup(svg, 'viewport');
5119
 // debounce canvas.viewbox.changed events
 // for smoother diagram interaction
 if (config.deferUpdate !== false) {
   this._viewboxChanged = debounce(bind(this._viewboxChanged, this), 300);
 }
5125
 eventBus.on('diagram.init', function() {
5127
   /**
    * An event indicating that the canvas is ready to be drawn on.
    *
    * @memberOf Canvas
    *
    * @event canvas.init
    *
    * @type {Object}
    * @property {SVGElement} svg the created svg element
    * @property {SVGElement} viewport the direct parent of diagram elements and shapes
    */
   eventBus.fire('canvas.init', {
     svg: svg,
     viewport: viewport
   });
5143
 }, this);
5145
 // reset viewbox on shape changes to
 // recompute the viewbox
 eventBus.on([
   'shape.added',
   'connection.added',
   'shape.removed',
   'connection.removed',
   'elements.changed',
   'root.set'
 ], function() {
   delete this._cachedViewbox;
 }, this);
5158
 eventBus.on('diagram.destroy', 500, this._destroy, this);
 eventBus.on('diagram.clear', 500, this._clear, this);
};
5162
Canvas.prototype._destroy = function(emit) {
 this._eventBus.fire('canvas.destroy', {
   svg: this._svg,
   viewport: this._viewport
 });
5168
 var parent = this._container.parentNode;
5170
 if (parent) {
   parent.removeChild(this._container);
 }
5174
 delete this._svg;
 delete this._container;
 delete this._layers;
 delete this._planes;
 delete this._rootElement;
 delete this._viewport;
};
5182
Canvas.prototype._clear = function() {
5184
 var self = this;
5186
 var allElements = this._elementRegistry.getAll();
5188
 // remove all elements
 allElements.forEach(function(element) {
   var type = getType(element);
5192
   if (type === 'root') {
     self.removeRootElement(element);
   } else {
     self._removeElement(element, type);
   }
 });
5199
 // remove all planes
 this._planes = [];
 this._rootElement = null;
5203
 // force recomputation of view box
 delete this._cachedViewbox;
};
5207
/**
* Returns the default layer on which
* all elements are drawn.
*
* @returns {SVGElement}
*/
Canvas.prototype.getDefaultLayer = function() {
 return this.getLayer(BASE_LAYER, PLANE_LAYER_INDEX);
};
5217
/**
* Returns a layer that is used to draw elements
* or annotations on it.
*
* Non-existing layers retrieved through this method
* will be created. During creation, the optional index
* may be used to create layers below or above existing layers.
* A layer with a certain index is always created above all
* existing layers with the same index.
*
* @param {string} name
* @param {number} index
*
* @returns {SVGElement}
*/
Canvas.prototype.getLayer = function(name, index) {
5234
 if (!name) {
   throw new Error('must specify a name');
 }
5238
 var layer = this._layers[name];
5240
 if (!layer) {
   layer = this._layers[name] = this._createLayer(name, index);
 }
5244
 // throw an error if layer creation / retrival is
 // requested on different index
 if (typeof index !== 'undefined' && layer.index !== index) {
   throw new Error('layer <' + name + '> already created at index <' + index + '>');
 }
5250
 return layer.group;
};
5253
/**
* For a given index, return the number of layers that have a higher index and
* are visible.
*
* This is used to determine the node a layer should be inserted at.
*
* @param {Number} index
* @returns {Number}
*/
Canvas.prototype._getChildIndex = function(index) {
 return reduce(this._layers, function(childIndex, layer) {
   if (layer.visible && index >= layer.index) {
     childIndex++;
   }
5268
   return childIndex;
 }, 0);
};
5272
/**
* Creates a given layer and returns it.
*
* @param {string} name
* @param {number} [index=0]
*
* @return {Object} layer descriptor with { index, group: SVGGroup }
*/
Canvas.prototype._createLayer = function(name, index) {
5282
 if (typeof index === 'undefined') {
   index = UTILITY_LAYER_INDEX;
 }
5286
 var childIndex = this._getChildIndex(index);
5288
 return {
   group: createGroup(this._viewport, 'layer-' + name, childIndex),
   index: index,
   visible: true
 };
};
5295
5296
/**
* Shows a given layer.
*
* @param {String} layer
* @returns {SVGElement}
*/
Canvas.prototype.showLayer = function(name) {
5304
 if (!name) {
   throw new Error('must specify a name');
 }
5308
 var layer = this._layers[name];
5310
 if (!layer) {
   throw new Error('layer <' + name + '> does not exist');
 }
5314
 var viewport = this._viewport;
 var group = layer.group;
 var index = layer.index;
5318
 if (layer.visible) {
   return group;
 }
5322
 var childIndex = this._getChildIndex(index);
5324
 viewport.insertBefore(group, viewport.childNodes[childIndex] || null);
5326
 layer.visible = true;
5328
 return group;
};
5331
/**
* Hides a given layer.
*
* @param {String} layer
* @returns {SVGElement}
*/
Canvas.prototype.hideLayer = function(name) {
5339
 if (!name) {
   throw new Error('must specify a name');
 }
5343
 var layer = this._layers[name];
5345
 if (!layer) {
   throw new Error('layer <' + name + '> does not exist');
 }
5349
 var group = layer.group;
5351
 if (!layer.visible) {
   return group;
 }
5355
 remove$2(group);
5357
 layer.visible = false;
5359
 return group;
};
5362
5363
Canvas.prototype._removeLayer = function(name) {
5365
 var layer = this._layers[name];
5367
 if (layer) {
   delete this._layers[name];
5370
   remove$2(layer.group);
 }
};
5374
/**
* Returns the currently active layer. Can be null.
*
* @returns {SVGElement|null}
*/
Canvas.prototype.getActiveLayer = function() {
 var plane = this._findPlaneForRoot(this.getRootElement());
5382
 if (!plane) {
   return null;
 }
5386
 return plane.layer;
};
5389
5390
/**
* Returns the plane which contains the given element.
*
* @param {string|djs.model.Base} element
*
* @return {djs.model.Base} root for element
*/
Canvas.prototype.findRoot = function(element) {
 if (typeof element === 'string') {
   element = this._elementRegistry.get(element);
 }
5402
 if (!element) {
   return;
 }
5406
 var plane = this._findPlaneForRoot(
   findRoot(element)
 ) || {};
5410
 return plane.rootElement;
};
5413
/**
* Return a list of all root elements on the diagram.
*
* @return {djs.model.Root[]}
*/
Canvas.prototype.getRootElements = function() {
 return this._planes.map(function(plane) {
   return plane.rootElement;
 });
};
5424
Canvas.prototype._findPlaneForRoot = function(rootElement) {
 return find(this._planes, function(plane) {
   return plane.rootElement === rootElement;
 });
};
5430
5431
/**
* Returns the html element that encloses the
* drawing canvas.
*
* @return {DOMNode}
*/
Canvas.prototype.getContainer = function() {
 return this._container;
};
5441
5442
// markers //////////////////////
5444
Canvas.prototype._updateMarker = function(element, marker, add) {
 var container;
5447
 if (!element.id) {
   element = this._elementRegistry.get(element);
 }
5451
 // we need to access all
 container = this._elementRegistry._elements[element.id];
5454
 if (!container) {
   return;
 }
5458
 forEach$2([ container.gfx, container.secondaryGfx ], function(gfx) {
   if (gfx) {
5461
     // invoke either addClass or removeClass based on mode
     if (add) {
       classes$1(gfx).add(marker);
     } else {
       classes$1(gfx).remove(marker);
     }
   }
 });
5470
 /**
  * An event indicating that a marker has been updated for an element
  *
  * @event element.marker.update
  * @type {Object}
  * @property {djs.model.Element} element the shape
  * @property {Object} gfx the graphical representation of the shape
  * @property {string} marker
  * @property {boolean} add true if the marker was added, false if it got removed
  */
 this._eventBus.fire('element.marker.update', { element: element, gfx: container.gfx, marker: marker, add: !!add });
};
5483
5484
/**
* Adds a marker to an element (basically a css class).
*
* Fires the element.marker.update event, making it possible to
* integrate extension into the marker life-cycle, too.
*
* @example
* canvas.addMarker('foo', 'some-marker');
*
* var fooGfx = canvas.getGraphics('foo');
*
* fooGfx; // <g class="... some-marker"> ... </g>
*
* @param {string|djs.model.Base} element
* @param {string} marker
*/
Canvas.prototype.addMarker = function(element, marker) {
 this._updateMarker(element, marker, true);
};
5504
5505
/**
* Remove a marker from an element.
*
* Fires the element.marker.update event, making it possible to
* integrate extension into the marker life-cycle, too.
*
* @param  {string|djs.model.Base} element
* @param  {string} marker
*/
Canvas.prototype.removeMarker = function(element, marker) {
 this._updateMarker(element, marker, false);
};
5518
/**
* Check the existence of a marker on element.
*
* @param  {string|djs.model.Base} element
* @param  {string} marker
*/
Canvas.prototype.hasMarker = function(element, marker) {
 if (!element.id) {
   element = this._elementRegistry.get(element);
 }
5529
 var gfx = this.getGraphics(element);
5531
 return classes$1(gfx).has(marker);
};
5534
/**
* Toggles a marker on an element.
*
* Fires the element.marker.update event, making it possible to
* integrate extension into the marker life-cycle, too.
*
* @param  {string|djs.model.Base} element
* @param  {string} marker
*/
Canvas.prototype.toggleMarker = function(element, marker) {
 if (this.hasMarker(element, marker)) {
   this.removeMarker(element, marker);
 } else {
   this.addMarker(element, marker);
 }
};
5551
/**
* Returns the current root element.
*
* Supports two different modes for handling root elements:
*
* 1. if no root element has been added before, an implicit root will be added
* and returned. This is used in applications that don't require explicit
* root elements.
*
* 2. when root elements have been added before calling `getRootElement`,
* root elements can be null. This is used for applications that want to manage
* root elements themselves.
*
* @returns {Object|djs.model.Root|null} rootElement.
*/
Canvas.prototype.getRootElement = function() {
 var rootElement = this._rootElement;
5569
 // can return null if root elements are present but none was set yet
 if (rootElement || this._planes.length) {
   return rootElement;
 }
5574
 return this.setRootElement(this.addRootElement(null));
};
5577
/**
* Adds a given root element and returns it.
*
* @param {Object|djs.model.Root} rootElement
*
* @return {Object|djs.model.Root} rootElement
*/
5585
Canvas.prototype.addRootElement = function(rootElement) {
 var idx = this._rootsIdx++;
5588
 if (!rootElement) {
   rootElement = {
     id: '__implicitroot_' + idx,
     children: [],
     isImplicit: true
   };
 }
5596
 var layerName = rootElement.layer = 'root-' + idx;
5598
 this._ensureValid('root', rootElement);
5600
 var layer = this.getLayer(layerName, PLANE_LAYER_INDEX);
5602
 this.hideLayer(layerName);
5604
 this._addRoot(rootElement, layer);
5606
 this._planes.push({
   rootElement: rootElement,
   layer: layer
 });
5611
 return rootElement;
};
5614
/**
* Removes a given rootElement and returns it.
*
* @param {djs.model.Root|String} rootElement
*
* @return {Object|djs.model.Root} rootElement
*/
Canvas.prototype.removeRootElement = function(rootElement) {
5623
 if (typeof rootElement === 'string') {
   rootElement = this._elementRegistry.get(rootElement);
 }
5627
 var plane = this._findPlaneForRoot(rootElement);
5629
 if (!plane) {
   return;
 }
5633
 // hook up life-cycle events
 this._removeRoot(rootElement);
5636
 // clean up layer
 this._removeLayer(rootElement.layer);
5639
 // clean up plane
 this._planes = this._planes.filter(function(plane) {
   return plane.rootElement !== rootElement;
 });
5644
 // clean up active root
 if (this._rootElement === rootElement) {
   this._rootElement = null;
 }
5649
 return rootElement;
};
5652
5653
// root element handling //////////////////////
5655
/**
* Sets a given element as the new root element for the canvas
* and returns the new root element.
*
* @param {Object|djs.model.Root} rootElement
*
* @return {Object|djs.model.Root} new root element
*/
Canvas.prototype.setRootElement = function(rootElement, override) {
5665
 if (isDefined(override)) {
   throw new Error('override not supported');
 }
5669
 if (rootElement === this._rootElement) {
   return;
 }
5673
 var plane;
5675
 if (!rootElement) {
   throw new Error('rootElement required');
 }
5679
 plane = this._findPlaneForRoot(rootElement);
5681
 // give set add semantics for backwards compatibility
 if (!plane) {
   rootElement = this.addRootElement(rootElement);
 }
5686
 this._setRoot(rootElement);
5688
 return rootElement;
};
5691
5692
Canvas.prototype._removeRoot = function(element) {
 var elementRegistry = this._elementRegistry,
     eventBus = this._eventBus;
5696
 // simulate element remove event sequence
 eventBus.fire('root.remove', { element: element });
 eventBus.fire('root.removed', { element: element });
5700
 elementRegistry.remove(element);
};
5703
5704
Canvas.prototype._addRoot = function(element, gfx) {
 var elementRegistry = this._elementRegistry,
     eventBus = this._eventBus;
5708
 // resemble element add event sequence
 eventBus.fire('root.add', { element: element });
5711
 elementRegistry.add(element, gfx);
5713
 eventBus.fire('root.added', { element: element, gfx: gfx });
};
5716
5717
Canvas.prototype._setRoot = function(rootElement, layer) {
5719
 var currentRoot = this._rootElement;
5721
 if (currentRoot) {
5723
   // un-associate previous root element <svg>
   this._elementRegistry.updateGraphics(currentRoot, null, true);
5726
   // hide previous layer
   this.hideLayer(currentRoot.layer);
 }
5730
 if (rootElement) {
5732
   if (!layer) {
     layer = this._findPlaneForRoot(rootElement).layer;
   }
5736
   // associate element with <svg>
   this._elementRegistry.updateGraphics(rootElement, this._svg, true);
5739
   // show root layer
   this.showLayer(rootElement.layer);
 }
5743
 this._rootElement = rootElement;
5745
 this._eventBus.fire('root.set', { element: rootElement });
};
5748
// add functionality //////////////////////
5750
Canvas.prototype._ensureValid = function(type, element) {
 if (!element.id) {
   throw new Error('element must have an id');
 }
5755
 if (this._elementRegistry.get(element.id)) {
   throw new Error('element <' + element.id + '> already exists');
 }
5759
 var requiredAttrs = REQUIRED_MODEL_ATTRS[type];
5761
 var valid = every(requiredAttrs, function(attr) {
   return typeof element[attr] !== 'undefined';
 });
5765
 if (!valid) {
   throw new Error(
     'must supply { ' + requiredAttrs.join(', ') + ' } with ' + type);
 }
};
5771
Canvas.prototype._setParent = function(element, parent, parentIndex) {
 add(parent.children, element, parentIndex);
 element.parent = parent;
};
5776
/**
* Adds an element to the canvas.
*
* This wires the parent <-> child relationship between the element and
* a explicitly specified parent or an implicit root element.
*
* During add it emits the events
*
*  * <{type}.add> (element, parent)
*  * <{type}.added> (element, gfx)
*
* Extensions may hook into these events to perform their magic.
*
* @param {string} type
* @param {Object|djs.model.Base} element
* @param {Object|djs.model.Base} [parent]
* @param {number} [parentIndex]
*
* @return {Object|djs.model.Base} the added element
*/
Canvas.prototype._addElement = function(type, element, parent, parentIndex) {
5798
 parent = parent || this.getRootElement();
5800
 var eventBus = this._eventBus,
     graphicsFactory = this._graphicsFactory;
5803
 this._ensureValid(type, element);
5805
 eventBus.fire(type + '.add', { element: element, parent: parent });
5807
 this._setParent(element, parent, parentIndex);
5809
 // create graphics
 var gfx = graphicsFactory.create(type, element, parentIndex);
5812
 this._elementRegistry.add(element, gfx);
5814
 // update its visual
 graphicsFactory.update(type, element, gfx);
5817
 eventBus.fire(type + '.added', { element: element, gfx: gfx });
5819
 return element;
};
5822
/**
* Adds a shape to the canvas
*
* @param {Object|djs.model.Shape} shape to add to the diagram
* @param {djs.model.Base} [parent]
* @param {number} [parentIndex]
*
* @return {djs.model.Shape} the added shape
*/
Canvas.prototype.addShape = function(shape, parent, parentIndex) {
 return this._addElement('shape', shape, parent, parentIndex);
};
5835
/**
* Adds a connection to the canvas
*
* @param {Object|djs.model.Connection} connection to add to the diagram
* @param {djs.model.Base} [parent]
* @param {number} [parentIndex]
*
* @return {djs.model.Connection} the added connection
*/
Canvas.prototype.addConnection = function(connection, parent, parentIndex) {
 return this._addElement('connection', connection, parent, parentIndex);
};
5848
5849
/**
* Internal remove element
*/
Canvas.prototype._removeElement = function(element, type) {
5854
 var elementRegistry = this._elementRegistry,
     graphicsFactory = this._graphicsFactory,
     eventBus = this._eventBus;
5858
 element = elementRegistry.get(element.id || element);
5860
 if (!element) {
5862
   // element was removed already
   return;
 }
5866
 eventBus.fire(type + '.remove', { element: element });
5868
 graphicsFactory.remove(element);
5870
 // unset parent <-> child relationship
 remove(element.parent && element.parent.children, element);
 element.parent = null;
5874
 eventBus.fire(type + '.removed', { element: element });
5876
 elementRegistry.remove(element);
5878
 return element;
};
5881
5882
/**
* Removes a shape from the canvas
*
* @param {string|djs.model.Shape} shape or shape id to be removed
*
* @return {djs.model.Shape} the removed shape
*/
Canvas.prototype.removeShape = function(shape) {
5891
 /**
  * An event indicating that a shape is about to be removed from the canvas.
  *
  * @memberOf Canvas
  *
  * @event shape.remove
  * @type {Object}
  * @property {djs.model.Shape} element the shape descriptor
  * @property {Object} gfx the graphical representation of the shape
  */
5902
 /**
  * An event indicating that a shape has been removed from the canvas.
  *
  * @memberOf Canvas
  *
  * @event shape.removed
  * @type {Object}
  * @property {djs.model.Shape} element the shape descriptor
  * @property {Object} gfx the graphical representation of the shape
  */
 return this._removeElement(shape, 'shape');
};
5915
5916
/**
* Removes a connection from the canvas
*
* @param {string|djs.model.Connection} connection or connection id to be removed
*
* @return {djs.model.Connection} the removed connection
*/
Canvas.prototype.removeConnection = function(connection) {
5925
 /**
  * An event indicating that a connection is about to be removed from the canvas.
  *
  * @memberOf Canvas
  *
  * @event connection.remove
  * @type {Object}
  * @property {djs.model.Connection} element the connection descriptor
  * @property {Object} gfx the graphical representation of the connection
  */
5936
 /**
  * An event indicating that a connection has been removed from the canvas.
  *
  * @memberOf Canvas
  *
  * @event connection.removed
  * @type {Object}
  * @property {djs.model.Connection} element the connection descriptor
  * @property {Object} gfx the graphical representation of the connection
  */
 return this._removeElement(connection, 'connection');
};
5949
5950
/**
* Return the graphical object underlaying a certain diagram element
*
* @param {string|djs.model.Base} element descriptor of the element
* @param {boolean} [secondary=false] whether to return the secondary connected element
*
* @return {SVGElement}
*/
Canvas.prototype.getGraphics = function(element, secondary) {
 return this._elementRegistry.getGraphics(element, secondary);
};
5962
5963
/**
* Perform a viewbox update via a given change function.
*
* @param {Function} changeFn
*/
Canvas.prototype._changeViewbox = function(changeFn) {
5970
 // notify others of the upcoming viewbox change
 this._eventBus.fire('canvas.viewbox.changing');
5973
 // perform actual change
 changeFn.apply(this);
5976
 // reset the cached viewbox so that
 // a new get operation on viewbox or zoom
 // triggers a viewbox re-computation
 this._cachedViewbox = null;
5981
 // notify others of the change; this step
 // may or may not be debounced
 this._viewboxChanged();
};
5986
Canvas.prototype._viewboxChanged = function() {
 this._eventBus.fire('canvas.viewbox.changed', { viewbox: this.viewbox() });
};
5990
5991
/**
* Gets or sets the view box of the canvas, i.e. the
* area that is currently displayed.
*
* The getter may return a cached viewbox (if it is currently
* changing). To force a recomputation, pass `false` as the first argument.
*
* @example
*
* canvas.viewbox({ x: 100, y: 100, width: 500, height: 500 })
*
* // sets the visible area of the diagram to (100|100) -> (600|100)
* // and and scales it according to the diagram width
*
* var viewbox = canvas.viewbox(); // pass `false` to force recomputing the box.
*
* console.log(viewbox);
* // {
* //   inner: Dimensions,
* //   outer: Dimensions,
* //   scale,
* //   x, y,
* //   width, height
* // }
*
* // if the current diagram is zoomed and scrolled, you may reset it to the
* // default zoom via this method, too:
*
* var zoomedAndScrolledViewbox = canvas.viewbox();
*
* canvas.viewbox({
*   x: 0,
*   y: 0,
*   width: zoomedAndScrolledViewbox.outer.width,
*   height: zoomedAndScrolledViewbox.outer.height
* });
*
* @param  {Object} [box] the new view box to set
* @param  {number} box.x the top left X coordinate of the canvas visible in view box
* @param  {number} box.y the top left Y coordinate of the canvas visible in view box
* @param  {number} box.width the visible width
* @param  {number} box.height
*
* @return {Object} the current view box
*/
Canvas.prototype.viewbox = function(box) {
6038
 if (box === undefined && this._cachedViewbox) {
   return this._cachedViewbox;
 }
6042
 var viewport = this._viewport,
     innerBox,
     outerBox = this.getSize(),
     matrix,
     activeLayer,
     transform,
     scale,
     x, y;
6051
 if (!box) {
6053
   // compute the inner box based on the
   // diagrams active layer. This allows us to exclude
   // external components, such as overlays
6057
   activeLayer = this._rootElement ? this.getActiveLayer() : null;
   innerBox = activeLayer && activeLayer.getBBox() || {};
6060
   transform = transform$1(viewport);
   matrix = transform ? transform.matrix : createMatrix();
   scale = round$b(matrix.a, 1000);
6064
   x = round$b(-matrix.e || 0, 1000);
   y = round$b(-matrix.f || 0, 1000);
6067
   box = this._cachedViewbox = {
     x: x ? x / scale : 0,
     y: y ? y / scale : 0,
     width: outerBox.width / scale,
     height: outerBox.height / scale,
     scale: scale,
     inner: {
       width: innerBox.width || 0,
       height: innerBox.height || 0,
       x: innerBox.x || 0,
       y: innerBox.y || 0
     },
     outer: outerBox
   };
6082
   return box;
 } else {
6085
   this._changeViewbox(function() {
     scale = Math.min(outerBox.width / box.width, outerBox.height / box.height);
6088
     var matrix = this._svg.createSVGMatrix()
       .scale(scale)
       .translate(-box.x, -box.y);
6092
     transform$1(viewport, matrix);
   });
 }
6096
 return box;
};
6099
6100
/**
* Gets or sets the scroll of the canvas.
*
* @param {Object} [delta] the new scroll to apply.
*
* @param {number} [delta.dx]
* @param {number} [delta.dy]
*/
Canvas.prototype.scroll = function(delta) {
6110
 var node = this._viewport;
 var matrix = node.getCTM();
6113
 if (delta) {
   this._changeViewbox(function() {
     delta = assign({ dx: 0, dy: 0 }, delta || {});
6117
     matrix = this._svg.createSVGMatrix().translate(delta.dx, delta.dy).multiply(matrix);
6119
     setCTM(node, matrix);
   });
 }
6123
 return { x: matrix.e, y: matrix.f };
};
6126
/**
* Scrolls the viewbox to contain the given element.
* Optionally specify a padding to be applied to the edges.
*
* @param {Object|String} [element] the element to scroll to.
* @param {Object|Number} [padding=100] the padding to be applied. Can also specify top, bottom, left and right.
*
*/
Canvas.prototype.scrollToElement = function(element, padding) {
 var defaultPadding = 100;
6137
 if (typeof element === 'string') {
   element = this._elementRegistry.get(element);
 }
6141
 // set to correct rootElement
 var rootElement = this.findRoot(element);
6144
 if (rootElement !== this.getRootElement()) {
   this.setRootElement(rootElement);
 }
6148
 if (!padding) {
   padding = {};
 }
 if (typeof padding === 'number') {
   defaultPadding = padding;
 }
6155
 padding = {
   top: padding.top || defaultPadding,
   right: padding.right || defaultPadding,
   bottom: padding.bottom || defaultPadding,
   left: padding.left || defaultPadding
 };
6162
 var elementBounds = getBBox(element),
     elementTrbl = asTRBL(elementBounds),
     viewboxBounds = this.viewbox(),
     zoom = this.zoom(),
     dx, dy;
6168
 // shrink viewboxBounds with padding
 viewboxBounds.y += padding.top / zoom;
 viewboxBounds.x += padding.left / zoom;
 viewboxBounds.width -= (padding.right + padding.left) / zoom;
 viewboxBounds.height -= (padding.bottom + padding.top) / zoom;
6174
 var viewboxTrbl = asTRBL(viewboxBounds);
6176
 var canFit = elementBounds.width < viewboxBounds.width && elementBounds.height < viewboxBounds.height;
6178
 if (!canFit) {
6180
   // top-left when element can't fit
   dx = elementBounds.x - viewboxBounds.x;
   dy = elementBounds.y - viewboxBounds.y;
6184
 } else {
6186
   var dRight = Math.max(0, elementTrbl.right - viewboxTrbl.right),
       dLeft = Math.min(0, elementTrbl.left - viewboxTrbl.left),
       dBottom = Math.max(0, elementTrbl.bottom - viewboxTrbl.bottom),
       dTop = Math.min(0, elementTrbl.top - viewboxTrbl.top);
6191
   dx = dRight || dLeft;
   dy = dBottom || dTop;
6194
 }
6196
 this.scroll({ dx: -dx * zoom, dy: -dy * zoom });
};
6199
/**
* Gets or sets the current zoom of the canvas, optionally zooming
* to the specified position.
*
* The getter may return a cached zoom level. Call it with `false` as
* the first argument to force recomputation of the current level.
*
* @param {string|number} [newScale] the new zoom level, either a number, i.e. 0.9,
*                                   or `fit-viewport` to adjust the size to fit the current viewport
* @param {string|Point} [center] the reference point { x: .., y: ..} to zoom to, 'auto' to zoom into mid or null
*
* @return {number} the current scale
*/
Canvas.prototype.zoom = function(newScale, center) {
6214
 if (!newScale) {
   return this.viewbox(newScale).scale;
 }
6218
 if (newScale === 'fit-viewport') {
   return this._fitViewport(center);
 }
6222
 var outer,
     matrix;
6225
 this._changeViewbox(function() {
6227
   if (typeof center !== 'object') {
     outer = this.viewbox().outer;
6230
     center = {
       x: outer.width / 2,
       y: outer.height / 2
     };
   }
6236
   matrix = this._setZoom(newScale, center);
 });
6239
 return round$b(matrix.a, 1000);
};
6242
function setCTM(node, m) {
 var mstr = 'matrix(' + m.a + ',' + m.b + ',' + m.c + ',' + m.d + ',' + m.e + ',' + m.f + ')';
 node.setAttribute('transform', mstr);
}
6247
Canvas.prototype._fitViewport = function(center) {
6249
 var vbox = this.viewbox(),
     outer = vbox.outer,
     inner = vbox.inner,
     newScale,
     newViewbox;
6255
 // display the complete diagram without zooming in.
 // instead of relying on internal zoom, we perform a
 // hard reset on the canvas viewbox to realize this
 //
 // if diagram does not need to be zoomed in, we focus it around
 // the diagram origin instead
6262
 if (inner.x >= 0 &&
     inner.y >= 0 &&
     inner.x + inner.width <= outer.width &&
     inner.y + inner.height <= outer.height &&
     !center) {
6268
   newViewbox = {
     x: 0,
     y: 0,
     width: Math.max(inner.width + inner.x, outer.width),
     height: Math.max(inner.height + inner.y, outer.height)
   };
 } else {
6276
   newScale = Math.min(1, outer.width / inner.width, outer.height / inner.height);
   newViewbox = {
     x: inner.x + (center ? inner.width / 2 - outer.width / newScale / 2 : 0),
     y: inner.y + (center ? inner.height / 2 - outer.height / newScale / 2 : 0),
     width: outer.width / newScale,
     height: outer.height / newScale
   };
 }
6285
 this.viewbox(newViewbox);
6287
 return this.viewbox(false).scale;
};
6290
6291
Canvas.prototype._setZoom = function(scale, center) {
6293
 var svg = this._svg,
     viewport = this._viewport;
6296
 var matrix = svg.createSVGMatrix();
 var point = svg.createSVGPoint();
6299
 var centerPoint,
     originalPoint,
     currentMatrix,
     scaleMatrix,
     newMatrix;
6305
 currentMatrix = viewport.getCTM();
6307
 var currentScale = currentMatrix.a;
6309
 if (center) {
   centerPoint = assign(point, center);
6312
   // revert applied viewport transformations
   originalPoint = centerPoint.matrixTransform(currentMatrix.inverse());
6315
   // create scale matrix
   scaleMatrix = matrix
     .translate(originalPoint.x, originalPoint.y)
     .scale(1 / currentScale * scale)
     .translate(-originalPoint.x, -originalPoint.y);
6321
   newMatrix = currentMatrix.multiply(scaleMatrix);
 } else {
   newMatrix = matrix.scale(scale);
 }
6326
 setCTM(this._viewport, newMatrix);
6328
 return newMatrix;
};
6331
6332
/**
* Returns the size of the canvas
*
* @return {Dimensions}
*/
Canvas.prototype.getSize = function() {
 return {
   width: this._container.clientWidth,
   height: this._container.clientHeight
 };
};
6344
6345
/**
* Return the absolute bounding box for the given element
*
* The absolute bounding box may be used to display overlays in the
* callers (browser) coordinate system rather than the zoomed in/out
* canvas coordinates.
*
* @param  {ElementDescriptor} element
* @return {Bounds} the absolute bounding box
*/
Canvas.prototype.getAbsoluteBBox = function(element) {
 var vbox = this.viewbox();
 var bbox;
6359
 // connection
 // use svg bbox
 if (element.waypoints) {
   var gfx = this.getGraphics(element);
6364
   bbox = gfx.getBBox();
 }
6367
 // shapes
 // use data
 else {
   bbox = element;
 }
6373
 var x = bbox.x * vbox.scale - vbox.x * vbox.scale;
 var y = bbox.y * vbox.scale - vbox.y * vbox.scale;
6376
 var width = bbox.width * vbox.scale;
 var height = bbox.height * vbox.scale;
6379
 return {
   x: x,
   y: y,
   width: width,
   height: height
 };
};
6387
/**
* Fires an event in order other modules can react to the
* canvas resizing
*/
Canvas.prototype.resized = function() {
6393
 // force recomputation of view box
 delete this._cachedViewbox;
6396
 this._eventBus.fire('canvas.resized');
};
6399
var ELEMENT_ID = 'data-element-id';
6401
6402
/**
* @class
*
* A registry that keeps track of all shapes in the diagram.
*/
function ElementRegistry(eventBus) {
 this._elements = {};
6410
 this._eventBus = eventBus;
}
6413
ElementRegistry.$inject = [ 'eventBus' ];
6415
/**
* Register a pair of (element, gfx, (secondaryGfx)).
*
* @param {djs.model.Base} element
* @param {SVGElement} gfx
* @param {SVGElement} [secondaryGfx] optional other element to register, too
*/
ElementRegistry.prototype.add = function(element, gfx, secondaryGfx) {
6424
 var id = element.id;
6426
 this._validateId(id);
6428
 // associate dom node with element
 attr$1(gfx, ELEMENT_ID, id);
6431
 if (secondaryGfx) {
   attr$1(secondaryGfx, ELEMENT_ID, id);
 }
6435
 this._elements[id] = { element: element, gfx: gfx, secondaryGfx: secondaryGfx };
};
6438
/**
* Removes an element from the registry.
*
* @param {djs.model.Base} element
*/
ElementRegistry.prototype.remove = function(element) {
 var elements = this._elements,
     id = element.id || element,
     container = id && elements[id];
6448
 if (container) {
6450
   // unset element id on gfx
   attr$1(container.gfx, ELEMENT_ID, '');
6453
   if (container.secondaryGfx) {
     attr$1(container.secondaryGfx, ELEMENT_ID, '');
   }
6457
   delete elements[id];
 }
};
6461
/**
* Update the id of an element
*
* @param {djs.model.Base} element
* @param {string} newId
*/
ElementRegistry.prototype.updateId = function(element, newId) {
6469
 this._validateId(newId);
6471
 if (typeof element === 'string') {
   element = this.get(element);
 }
6475
 this._eventBus.fire('element.updateId', {
   element: element,
   newId: newId
 });
6480
 var gfx = this.getGraphics(element),
     secondaryGfx = this.getGraphics(element, true);
6483
 this.remove(element);
6485
 element.id = newId;
6487
 this.add(element, gfx, secondaryGfx);
};
6490
/**
* Update the graphics of an element
*
* @param {djs.model.Base} element
* @param {SVGElement} gfx
* @param {boolean} [secondary=false] whether to update the secondary connected element
*/
ElementRegistry.prototype.updateGraphics = function(filter, gfx, secondary) {
 var id = filter.id || filter;
6500
 var container = this._elements[id];
6502
 if (secondary) {
   container.secondaryGfx = gfx;
 } else {
   container.gfx = gfx;
 }
6508
 if (gfx) {
   attr$1(gfx, ELEMENT_ID, id);
 }
6512
 return gfx;
};
6515
/**
* Return the model element for a given id or graphics.
*
* @example
*
* elementRegistry.get('SomeElementId_1');
* elementRegistry.get(gfx);
*
*
* @param {string|SVGElement} filter for selecting the element
*
* @return {djs.model.Base}
*/
ElementRegistry.prototype.get = function(filter) {
 var id;
6531
 if (typeof filter === 'string') {
   id = filter;
 } else {
   id = filter && attr$1(filter, ELEMENT_ID);
 }
6537
 var container = this._elements[id];
 return container && container.element;
};
6541
/**
* Return all elements that match a given filter function.
*
* @param {Function} fn
*
* @return {Array<djs.model.Base>}
*/
ElementRegistry.prototype.filter = function(fn) {
6550
 var filtered = [];
6552
 this.forEach(function(element, gfx) {
   if (fn(element, gfx)) {
     filtered.push(element);
   }
 });
6558
 return filtered;
};
6561
/**
* Return the first element that satisfies the provided testing function.
*
* @param {Function} fn
*
* @return {djs.model.Base}
*/
ElementRegistry.prototype.find = function(fn) {
 var map = this._elements,
     keys = Object.keys(map);
6572
 for (var i = 0; i < keys.length; i++) {
   var id = keys[i],
       container = map[id],
       element = container.element,
       gfx = container.gfx;
6578
   if (fn(element, gfx)) {
     return element;
   }
 }
};
6584
/**
* Return all rendered model elements.
*
* @return {Array<djs.model.Base>}
*/
ElementRegistry.prototype.getAll = function() {
 return this.filter(function(e) { return e; });
};
6593
/**
* Iterate over all diagram elements.
*
* @param {Function} fn
*/
ElementRegistry.prototype.forEach = function(fn) {
6600
 var map = this._elements;
6602
 Object.keys(map).forEach(function(id) {
   var container = map[id],
       element = container.element,
       gfx = container.gfx;
6607
   return fn(element, gfx);
 });
};
6611
/**
* Return the graphical representation of an element or its id.
*
* @example
* elementRegistry.getGraphics('SomeElementId_1');
* elementRegistry.getGraphics(rootElement); // <g ...>
*
* elementRegistry.getGraphics(rootElement, true); // <svg ...>
*
*
* @param {string|djs.model.Base} filter
* @param {boolean} [secondary=false] whether to return the secondary connected element
*
* @return {SVGElement}
*/
ElementRegistry.prototype.getGraphics = function(filter, secondary) {
 var id = filter.id || filter;
6629
 var container = this._elements[id];
 return container && (secondary ? container.secondaryGfx : container.gfx);
};
6633
/**
* Validate the suitability of the given id and signals a problem
* with an exception.
*
* @param {string} id
*
* @throws {Error} if id is empty or already assigned
*/
ElementRegistry.prototype._validateId = function(id) {
 if (!id) {
   throw new Error('element must have an id');
 }
6646
 if (this._elements[id]) {
   throw new Error('element with id ' + id + ' already added');
 }
};
6651
var objectRefs = {exports: {}};
6653
var collection = {};
6655
/**
* An empty collection stub. Use {@link RefsCollection.extend} to extend a
* collection with ref semantics.
*
* @class RefsCollection
*/
6662
/**
* Extends a collection with {@link Refs} aware methods
*
* @memberof RefsCollection
* @static
*
* @param  {Array<Object>} collection
* @param  {Refs} refs instance
* @param  {Object} property represented by the collection
* @param  {Object} target object the collection is attached to
*
* @return {RefsCollection<Object>} the extended array
*/
function extend(collection, refs, property, target) {
6677
 var inverseProperty = property.inverse;
6679
 /**
  * Removes the given element from the array and returns it.
  *
  * @method RefsCollection#remove
  *
  * @param {Object} element the element to remove
  */
 Object.defineProperty(collection, 'remove', {
   value: function(element) {
     var idx = this.indexOf(element);
     if (idx !== -1) {
       this.splice(idx, 1);
6692
       // unset inverse
       refs.unset(element, inverseProperty, target);
     }
6696
     return element;
   }
 });
6700
 /**
  * Returns true if the collection contains the given element
  *
  * @method RefsCollection#contains
  *
  * @param {Object} element the element to check for
  */
 Object.defineProperty(collection, 'contains', {
   value: function(element) {
     return this.indexOf(element) !== -1;
   }
 });
6713
 /**
  * Adds an element to the array, unless it exists already (set semantics).
  *
  * @method RefsCollection#add
  *
  * @param {Object} element the element to add
  * @param {Number} optional index to add element to
  *                 (possibly moving other elements around)
  */
 Object.defineProperty(collection, 'add', {
   value: function(element, idx) {
6725
     var currentIdx = this.indexOf(element);
6727
     if (typeof idx === 'undefined') {
6729
       if (currentIdx !== -1) {
         // element already in collection (!)
         return;
       }
6734
       // add to end of array, as no idx is specified
       idx = this.length;
     }
6738
     // handle already in collection
     if (currentIdx !== -1) {
6741
       // remove element from currentIdx
       this.splice(currentIdx, 1);
     }
6745
     // add element at idx
     this.splice(idx, 0, element);
6748
     if (currentIdx === -1) {
       // set inverse, unless element was
       // in collection already
       refs.set(element, inverseProperty, target);
     }
   }
 });
6756
 // a simple marker, identifying this element
 // as being a refs collection
 Object.defineProperty(collection, '__refs_collection', {
   value: true
 });
6762
 return collection;
}
6765
6766
function isExtended(collection) {
 return collection.__refs_collection === true;
}
6770
collection.extend = extend;
6772
collection.isExtended = isExtended;
6774
var Collection = collection;
6776
function hasOwnProperty$1(e, property) {
 return Object.prototype.hasOwnProperty.call(e, property.name || property);
}
6780
function defineCollectionProperty(ref, property, target) {
6782
 var collection = Collection.extend(target[property.name] || [], ref, property, target);
6784
 Object.defineProperty(target, property.name, {
   enumerable: property.enumerable,
   value: collection
 });
6789
 if (collection.length) {
6791
   collection.forEach(function(o) {
     ref.set(o, property.inverse, target);
   });
 }
}
6797
6798
function defineProperty$1(ref, property, target) {
6800
 var inverseProperty = property.inverse;
6802
 var _value = target[property.name];
6804
 Object.defineProperty(target, property.name, {
   configurable: property.configurable,
   enumerable: property.enumerable,
6808
   get: function() {
     return _value;
   },
6812
   set: function(value) {
6814
     // return if we already performed all changes
     if (value === _value) {
       return;
     }
6819
     var old = _value;
6821
     // temporary set null
     _value = null;
6824
     if (old) {
       ref.unset(old, inverseProperty, target);
     }
6828
     // set new value
     _value = value;
6831
     // set inverse value
     ref.set(_value, inverseProperty, target);
   }
 });
6836
}
6838
/**
* Creates a new references object defining two inversly related
* attribute descriptors a and b.
*
* <p>
*   When bound to an object using {@link Refs#bind} the references
*   get activated and ensure that add and remove operations are applied
*   reversely, too.
* </p>
*
* <p>
*   For attributes represented as collections {@link Refs} provides the
*   {@link RefsCollection#add}, {@link RefsCollection#remove} and {@link RefsCollection#contains} extensions
*   that must be used to properly hook into the inverse change mechanism.
* </p>
*
* @class Refs
*
* @classdesc A bi-directional reference between two attributes.
*
* @param {Refs.AttributeDescriptor} a property descriptor
* @param {Refs.AttributeDescriptor} b property descriptor
*
* @example
*
* var refs = Refs({ name: 'wheels', collection: true, enumerable: true }, { name: 'car' });
*
* var car = { name: 'toyota' };
* var wheels = [{ pos: 'front-left' }, { pos: 'front-right' }];
*
* refs.bind(car, 'wheels');
*
* car.wheels // []
* car.wheels.add(wheels[0]);
* car.wheels.add(wheels[1]);
*
* car.wheels // [{ pos: 'front-left' }, { pos: 'front-right' }]
*
* wheels[0].car // { name: 'toyota' };
* car.wheels.remove(wheels[0]);
*
* wheels[0].car // undefined
*/
function Refs$1(a, b) {
6883
 if (!(this instanceof Refs$1)) {
   return new Refs$1(a, b);
 }
6887
 // link
 a.inverse = b;
 b.inverse = a;
6891
 this.props = {};
 this.props[a.name] = a;
 this.props[b.name] = b;
}
6896
/**
* Binds one side of a bi-directional reference to a
* target object.
*
* @memberOf Refs
*
* @param  {Object} target
* @param  {String} property
*/
Refs$1.prototype.bind = function(target, property) {
 if (typeof property === 'string') {
   if (!this.props[property]) {
     throw new Error('no property <' + property + '> in ref');
   }
   property = this.props[property];
 }
6913
 if (property.collection) {
   defineCollectionProperty(this, property, target);
 } else {
   defineProperty$1(this, property, target);
 }
};
6920
Refs$1.prototype.ensureRefsCollection = function(target, property) {
6922
 var collection = target[property.name];
6924
 if (!Collection.isExtended(collection)) {
   defineCollectionProperty(this, property, target);
 }
6928
 return collection;
};
6931
Refs$1.prototype.ensureBound = function(target, property) {
 if (!hasOwnProperty$1(target, property)) {
   this.bind(target, property);
 }
};
6937
Refs$1.prototype.unset = function(target, property, value) {
6939
 if (target) {
   this.ensureBound(target, property);
6942
   if (property.collection) {
     this.ensureRefsCollection(target, property).remove(value);
   } else {
     target[property.name] = undefined;
   }
 }
};
6950
Refs$1.prototype.set = function(target, property, value) {
6952
 if (target) {
   this.ensureBound(target, property);
6955
   if (property.collection) {
     this.ensureRefsCollection(target, property).add(value);
   } else {
     target[property.name] = value;
   }
 }
};
6963
var refs = Refs$1;
6965
objectRefs.exports = refs;
6967
objectRefs.exports.Collection = collection;
6969
var Refs = objectRefs.exports;
6971
var parentRefs = new Refs({ name: 'children', enumerable: true, collection: true }, { name: 'parent' }),
   labelRefs = new Refs({ name: 'labels', enumerable: true, collection: true }, { name: 'labelTarget' }),
   attacherRefs = new Refs({ name: 'attachers', collection: true }, { name: 'host' }),
   outgoingRefs = new Refs({ name: 'outgoing', collection: true }, { name: 'source' }),
   incomingRefs = new Refs({ name: 'incoming', collection: true }, { name: 'target' });
6977
/**
* @namespace djs.model
*/
6981
/**
* @memberOf djs.model
*/
6985
/**
* The basic graphical representation
*
* @class
*
* @abstract
*/
function Base$1() {
6994
 /**
  * The object that backs up the shape
  *
  * @name Base#businessObject
  * @type Object
  */
 Object.defineProperty(this, 'businessObject', {
   writable: true
 });
7004
7005
 /**
  * Single label support, will mapped to multi label array
  *
  * @name Base#label
  * @type Object
  */
 Object.defineProperty(this, 'label', {
   get: function() {
     return this.labels[0];
   },
   set: function(newLabel) {
7017
     var label = this.label,
         labels = this.labels;
7020
     if (!newLabel && label) {
       labels.remove(label);
     } else {
       labels.add(newLabel, 0);
     }
   }
 });
7028
 /**
  * The parent shape
  *
  * @name Base#parent
  * @type Shape
  */
 parentRefs.bind(this, 'parent');
7036
 /**
  * The list of labels
  *
  * @name Base#labels
  * @type Label
  */
 labelRefs.bind(this, 'labels');
7044
 /**
  * The list of outgoing connections
  *
  * @name Base#outgoing
  * @type Array<Connection>
  */
 outgoingRefs.bind(this, 'outgoing');
7052
 /**
  * The list of incoming connections
  *
  * @name Base#incoming
  * @type Array<Connection>
  */
 incomingRefs.bind(this, 'incoming');
}
7061
7062
/**
* A graphical object
*
* @class
* @constructor
*
* @extends Base
*/
function Shape() {
 Base$1.call(this);
7073
 /**
  * Indicates frame shapes
  *
  * @name Shape#isFrame
  * @type boolean
  */
7080
 /**
  * The list of children
  *
  * @name Shape#children
  * @type Array<Base>
  */
 parentRefs.bind(this, 'children');
7088
 /**
  * @name Shape#host
  * @type Shape
  */
 attacherRefs.bind(this, 'host');
7094
 /**
  * @name Shape#attachers
  * @type Shape
  */
 attacherRefs.bind(this, 'attachers');
}
7101
inherits$1(Shape, Base$1);
7103
7104
/**
* A root graphical object
*
* @class
* @constructor
*
* @extends Shape
*/
function Root() {
 Shape.call(this);
}
7116
inherits$1(Root, Shape);
7118
7119
/**
* A label for an element
*
* @class
* @constructor
*
* @extends Shape
*/
function Label() {
 Shape.call(this);
7130
 /**
  * The labeled element
  *
  * @name Label#labelTarget
  * @type Base
  */
 labelRefs.bind(this, 'labelTarget');
}
7139
inherits$1(Label, Shape);
7141
7142
/**
* A connection between two elements
*
* @class
* @constructor
*
* @extends Base
*/
function Connection() {
 Base$1.call(this);
7153
 /**
  * The element this connection originates from
  *
  * @name Connection#source
  * @type Base
  */
 outgoingRefs.bind(this, 'source');
7161
 /**
  * The element this connection points to
  *
  * @name Connection#target
  * @type Base
  */
 incomingRefs.bind(this, 'target');
}
7170
inherits$1(Connection, Base$1);
7172
7173
var types$6 = {
 connection: Connection,
 shape: Shape,
 label: Label,
 root: Root
};
7180
/**
* Creates a new model element of the specified type
*
* @method create
*
* @example
*
* var shape1 = Model.create('shape', { x: 10, y: 10, width: 100, height: 100 });
* var shape2 = Model.create('shape', { x: 210, y: 210, width: 100, height: 100 });
*
* var connection = Model.create('connection', { waypoints: [ { x: 110, y: 55 }, {x: 210, y: 55 } ] });
*
* @param  {string} type lower-cased model name
* @param  {Object} attrs attributes to initialize the new model instance with
*
* @return {Base} the new model instance
*/
function create(type, attrs) {
 var Type = types$6[type];
 if (!Type) {
   throw new Error('unknown type: <' + type + '>');
 }
 return assign(new Type(), attrs);
}
7205
/**
* A factory for diagram-js shapes
*/
function ElementFactory$1() {
 this._uid = 12;
}
7212
7213
ElementFactory$1.prototype.createRoot = function(attrs) {
 return this.create('root', attrs);
};
7217
ElementFactory$1.prototype.createLabel = function(attrs) {
 return this.create('label', attrs);
};
7221
ElementFactory$1.prototype.createShape = function(attrs) {
 return this.create('shape', attrs);
};
7225
ElementFactory$1.prototype.createConnection = function(attrs) {
 return this.create('connection', attrs);
};
7229
/**
* Create a model element with the given type and
* a number of pre-set attributes.
*
* @param  {string} type
* @param  {Object} attrs
* @return {djs.model.Base} the newly created model instance
*/
ElementFactory$1.prototype.create = function(type, attrs) {
7239
 attrs = assign({}, attrs || {});
7241
 if (!attrs.id) {
   attrs.id = type + '_' + (this._uid++);
 }
7245
 return create(type, attrs);
};
7248
var FN_REF = '__fn';
7250
var DEFAULT_PRIORITY$5 = 1000;
7252
var slice = Array.prototype.slice;
7254
/**
* A general purpose event bus.
*
* This component is used to communicate across a diagram instance.
* Other parts of a diagram can use it to listen to and broadcast events.
*
*
* ## Registering for Events
*
* The event bus provides the {@link EventBus#on} and {@link EventBus#once}
* methods to register for events. {@link EventBus#off} can be used to
* remove event registrations. Listeners receive an instance of {@link Event}
* as the first argument. It allows them to hook into the event execution.
*
* ```javascript
*
* // listen for event
* eventBus.on('foo', function(event) {
*
*   // access event type
*   event.type; // 'foo'
*
*   // stop propagation to other listeners
*   event.stopPropagation();
*
*   // prevent event default
*   event.preventDefault();
* });
*
* // listen for event with custom payload
* eventBus.on('bar', function(event, payload) {
*   console.log(payload);
* });
*
* // listen for event returning value
* eventBus.on('foobar', function(event) {
*
*   // stop event propagation + prevent default
*   return false;
*
*   // stop event propagation + return custom result
*   return {
*     complex: 'listening result'
*   };
* });
*
*
* // listen with custom priority (default=1000, higher is better)
* eventBus.on('priorityfoo', 1500, function(event) {
*   console.log('invoked first!');
* });
*
*
* // listen for event and pass the context (`this`)
* eventBus.on('foobar', function(event) {
*   this.foo();
* }, this);
* ```
*
*
* ## Emitting Events
*
* Events can be emitted via the event bus using {@link EventBus#fire}.
*
* ```javascript
*
* // false indicates that the default action
* // was prevented by listeners
* if (eventBus.fire('foo') === false) {
*   console.log('default has been prevented!');
* };
*
*
* // custom args + return value listener
* eventBus.on('sum', function(event, a, b) {
*   return a + b;
* });
*
* // you can pass custom arguments + retrieve result values.
* var sum = eventBus.fire('sum', 1, 2);
* console.log(sum); // 3
* ```
*/
function EventBus() {
 this._listeners = {};
7340
 // cleanup on destroy on lowest priority to allow
 // message passing until the bitter end
 this.on('diagram.destroy', 1, this._destroy, this);
}
7345
7346
/**
* Register an event listener for events with the given name.
*
* The callback will be invoked with `event, ...additionalArguments`
* that have been passed to {@link EventBus#fire}.
*
* Returning false from a listener will prevent the events default action
* (if any is specified). To stop an event from being processed further in
* other listeners execute {@link Event#stopPropagation}.
*
* Returning anything but `undefined` from a listener will stop the listener propagation.
*
* @param {string|Array<string>} events
* @param {number} [priority=1000] the priority in which this listener is called, larger is higher
* @param {Function} callback
* @param {Object} [that] Pass context (`this`) to the callback
*/
EventBus.prototype.on = function(events, priority, callback, that) {
7365
 events = isArray$4(events) ? events : [ events ];
7367
 if (isFunction(priority)) {
   that = callback;
   callback = priority;
   priority = DEFAULT_PRIORITY$5;
 }
7373
 if (!isNumber(priority)) {
   throw new Error('priority must be a number');
 }
7377
 var actualCallback = callback;
7379
 if (that) {
   actualCallback = bind(callback, that);
7382
   // make sure we remember and are able to remove
   // bound callbacks via {@link #off} using the original
   // callback
   actualCallback[FN_REF] = callback[FN_REF] || callback;
 }
7388
 var self = this;
7390
 events.forEach(function(e) {
   self._addListener(e, {
     priority: priority,
     callback: actualCallback,
     next: null
   });
 });
};
7399
7400
/**
* Register an event listener that is executed only once.
*
* @param {string} event the event name to register for
* @param {number} [priority=1000] the priority in which this listener is called, larger is higher
* @param {Function} callback the callback to execute
* @param {Object} [that] Pass context (`this`) to the callback
*/
EventBus.prototype.once = function(event, priority, callback, that) {
 var self = this;
7411
 if (isFunction(priority)) {
   that = callback;
   callback = priority;
   priority = DEFAULT_PRIORITY$5;
 }
7417
 if (!isNumber(priority)) {
   throw new Error('priority must be a number');
 }
7421
 function wrappedCallback() {
   wrappedCallback.__isTomb = true;
7424
   var result = callback.apply(that, arguments);
7426
   self.off(event, wrappedCallback);
7428
   return result;
 }
7431
 // make sure we remember and are able to remove
 // bound callbacks via {@link #off} using the original
 // callback
 wrappedCallback[FN_REF] = callback;
7436
 this.on(event, priority, wrappedCallback);
};
7439
7440
/**
* Removes event listeners by event and callback.
*
* If no callback is given, all listeners for a given event name are being removed.
*
* @param {string|Array<string>} events
* @param {Function} [callback]
*/
EventBus.prototype.off = function(events, callback) {
7450
 events = isArray$4(events) ? events : [ events ];
7452
 var self = this;
7454
 events.forEach(function(event) {
   self._removeListener(event, callback);
 });
7458
};
7460
7461
/**
* Create an EventBus event.
*
* @param {Object} data
*
* @return {Object} event, recognized by the eventBus
*/
EventBus.prototype.createEvent = function(data) {
 var event = new InternalEvent();
7471
 event.init(data);
7473
 return event;
};
7476
7477
/**
* Fires a named event.
*
* @example
*
* // fire event by name
* events.fire('foo');
*
* // fire event object with nested type
* var event = { type: 'foo' };
* events.fire(event);
*
* // fire event with explicit type
* var event = { x: 10, y: 20 };
* events.fire('element.moved', event);
*
* // pass additional arguments to the event
* events.on('foo', function(event, bar) {
*   alert(bar);
* });
*
* events.fire({ type: 'foo' }, 'I am bar!');
*
* @param {string} [name] the optional event name
* @param {Object} [event] the event object
* @param {...Object} additional arguments to be passed to the callback functions
*
* @return {boolean} the events return value, if specified or false if the
*                   default action was prevented by listeners
*/
EventBus.prototype.fire = function(type, data) {
 var event,
     firstListener,
     returnValue,
     args;
7513
 args = slice.call(arguments);
7515
 if (typeof type === 'object') {
   data = type;
   type = data.type;
 }
7520
 if (!type) {
   throw new Error('no event type specified');
 }
7524
 firstListener = this._listeners[type];
7526
 if (!firstListener) {
   return;
 }
7530
 // we make sure we fire instances of our home made
 // events here. We wrap them only once, though
 if (data instanceof InternalEvent) {
7534
   // we are fine, we alread have an event
   event = data;
 } else {
   event = this.createEvent(data);
 }
7540
 // ensure we pass the event as the first parameter
 args[0] = event;
7543
 // original event type (in case we delegate)
 var originalType = event.type;
7546
 // update event type before delegation
 if (type !== originalType) {
   event.type = type;
 }
7551
 try {
   returnValue = this._invokeListeners(event, args, firstListener);
 } finally {
7555
   // reset event type after delegation
   if (type !== originalType) {
     event.type = originalType;
   }
 }
7561
 // set the return value to false if the event default
 // got prevented and no other return value exists
 if (returnValue === undefined && event.defaultPrevented) {
   returnValue = false;
 }
7567
 return returnValue;
};
7570
7571
EventBus.prototype.handleError = function(error) {
 return this.fire('error', { error: error }) === false;
};
7575
7576
EventBus.prototype._destroy = function() {
 this._listeners = {};
};
7580
EventBus.prototype._invokeListeners = function(event, args, listener) {
7582
 var returnValue;
7584
 while (listener) {
7586
   // handle stopped propagation
   if (event.cancelBubble) {
     break;
   }
7591
   returnValue = this._invokeListener(event, args, listener);
7593
   listener = listener.next;
 }
7596
 return returnValue;
};
7599
EventBus.prototype._invokeListener = function(event, args, listener) {
7601
 var returnValue;
7603
 if (listener.callback.__isTomb) {
   return returnValue;
 }
7607
 try {
7609
   // returning false prevents the default action
   returnValue = invokeFunction(listener.callback, args);
7612
   // stop propagation on return value
   if (returnValue !== undefined) {
     event.returnValue = returnValue;
     event.stopPropagation();
   }
7618
   // prevent default on return false
   if (returnValue === false) {
     event.preventDefault();
   }
 } catch (error) {
   if (!this.handleError(error)) {
     console.error('unhandled error in event listener', error);
7626
     throw error;
   }
 }
7630
 return returnValue;
};
7633
/*
* Add new listener with a certain priority to the list
* of listeners (for the given event).
*
* The semantics of listener registration / listener execution are
* first register, first serve: New listeners will always be inserted
* after existing listeners with the same priority.
*
* Example: Inserting two listeners with priority 1000 and 1300
*
*    * before: [ 1500, 1500, 1000, 1000 ]
*    * after: [ 1500, 1500, (new=1300), 1000, 1000, (new=1000) ]
*
* @param {string} event
* @param {Object} listener { priority, callback }
*/
EventBus.prototype._addListener = function(event, newListener) {
7651
 var listener = this._getListeners(event),
     previousListener;
7654
 // no prior listeners
 if (!listener) {
   this._setListeners(event, newListener);
7658
   return;
 }
7661
 // ensure we order listeners by priority from
 // 0 (high) to n > 0 (low)
 while (listener) {
7665
   if (listener.priority < newListener.priority) {
7667
     newListener.next = listener;
7669
     if (previousListener) {
       previousListener.next = newListener;
     } else {
       this._setListeners(event, newListener);
     }
7675
     return;
   }
7678
   previousListener = listener;
   listener = listener.next;
 }
7682
 // add new listener to back
 previousListener.next = newListener;
};
7686
7687
EventBus.prototype._getListeners = function(name) {
 return this._listeners[name];
};
7691
EventBus.prototype._setListeners = function(name, listener) {
 this._listeners[name] = listener;
};
7695
EventBus.prototype._removeListener = function(event, callback) {
7697
 var listener = this._getListeners(event),
     nextListener,
     previousListener,
     listenerCallback;
7702
 if (!callback) {
7704
   // clear listeners
   this._setListeners(event, null);
7707
   return;
 }
7710
 while (listener) {
7712
   nextListener = listener.next;
7714
   listenerCallback = listener.callback;
7716
   if (listenerCallback === callback || listenerCallback[FN_REF] === callback) {
     if (previousListener) {
       previousListener.next = nextListener;
     } else {
7721
       // new first listener
       this._setListeners(event, nextListener);
     }
   }
7726
   previousListener = listener;
   listener = nextListener;
 }
};
7731
/**
* A event that is emitted via the event bus.
*/
function InternalEvent() { }
7736
InternalEvent.prototype.stopPropagation = function() {
 this.cancelBubble = true;
};
7740
InternalEvent.prototype.preventDefault = function() {
 this.defaultPrevented = true;
};
7744
InternalEvent.prototype.init = function(data) {
 assign(this, data || {});
};
7748
7749
/**
* Invoke function. Be fast...
*
* @param {Function} fn
* @param {Array<Object>} args
*
* @return {Any}
*/
function invokeFunction(fn, args) {
 return fn.apply(null, args);
}
7761
/**
* SVGs for elements are generated by the {@link GraphicsFactory}.
*
* This utility gives quick access to the important semantic
* parts of an element.
*/
7768
/**
* Returns the visual part of a diagram element
*
* @param {Snap<SVGElement>} gfx
*
* @return {Snap<SVGElement>}
*/
function getVisual(gfx) {
 return gfx.childNodes[0];
}
7779
/**
* Returns the children for a given diagram element.
*
* @param {Snap<SVGElement>} gfx
* @return {Snap<SVGElement>}
*/
function getChildren$1(gfx) {
 return gfx.parentNode.childNodes[1];
}
7789
/**
* @param {<SVGElement>} element
* @param {number} x
* @param {number} y
* @param {number} angle
* @param {number} amount
*/
function transform(gfx, x, y, angle, amount) {
 var translate = createTransform();
 translate.setTranslate(x, y);
7800
 var rotate = createTransform();
 rotate.setRotate(angle || 0, 0, 0);
7803
 var scale = createTransform();
 scale.setScale(amount || 1, amount || 1);
7806
 transform$1(gfx, [ translate, rotate, scale ]);
}
7809
7810
/**
* @param {SVGElement} element
* @param {number} x
* @param {number} y
*/
function translate$2(gfx, x, y) {
 var translate = createTransform();
 translate.setTranslate(x, y);
7819
 transform$1(gfx, translate);
}
7822
7823
/**
* @param {SVGElement} element
* @param {number} angle
*/
function rotate(gfx, angle) {
 var rotate = createTransform();
 rotate.setRotate(angle, 0, 0);
7831
 transform$1(gfx, rotate);
}
7834
/**
* A factory that creates graphical elements
*
* @param {EventBus} eventBus
* @param {ElementRegistry} elementRegistry
*/
function GraphicsFactory(eventBus, elementRegistry) {
 this._eventBus = eventBus;
 this._elementRegistry = elementRegistry;
}
7845
GraphicsFactory.$inject = [ 'eventBus' , 'elementRegistry' ];
7847
7848
GraphicsFactory.prototype._getChildrenContainer = function(element) {
7850
 var gfx = this._elementRegistry.getGraphics(element);
7852
 var childrenGfx;
7854
 // root element
 if (!element.parent) {
   childrenGfx = gfx;
 } else {
   childrenGfx = getChildren$1(gfx);
   if (!childrenGfx) {
     childrenGfx = create$1('g');
     classes$1(childrenGfx).add('djs-children');
7863
     append(gfx.parentNode, childrenGfx);
   }
 }
7867
 return childrenGfx;
};
7870
/**
* Clears the graphical representation of the element and returns the
* cleared visual (the <g class="djs-visual" /> element).
*/
GraphicsFactory.prototype._clear = function(gfx) {
 var visual = getVisual(gfx);
7877
 clear(visual);
7879
 return visual;
};
7882
/**
* Creates a gfx container for shapes and connections
*
* The layout is as follows:
*
* <g class="djs-group">
*
*   <!-- the gfx -->
*   <g class="djs-element djs-(shape|connection|frame)">
*     <g class="djs-visual">
*       <!-- the renderer draws in here -->
*     </g>
*
*     <!-- extensions (overlays, click box, ...) goes here
*   </g>
*
*   <!-- the gfx child nodes -->
*   <g class="djs-children"></g>
* </g>
*
* @param {string} type the type of the element, i.e. shape | connection
* @param {SVGElement} [childrenGfx]
* @param {number} [parentIndex] position to create container in parent
* @param {boolean} [isFrame] is frame element
*
* @return {SVGElement}
*/
GraphicsFactory.prototype._createContainer = function(
   type, childrenGfx, parentIndex, isFrame
) {
 var outerGfx = create$1('g');
 classes$1(outerGfx).add('djs-group');
7915
 // insert node at position
 if (typeof parentIndex !== 'undefined') {
   prependTo(outerGfx, childrenGfx, childrenGfx.childNodes[parentIndex]);
 } else {
   append(childrenGfx, outerGfx);
 }
7922
 var gfx = create$1('g');
 classes$1(gfx).add('djs-element');
 classes$1(gfx).add('djs-' + type);
7926
 if (isFrame) {
   classes$1(gfx).add('djs-frame');
 }
7930
 append(outerGfx, gfx);
7932
 // create visual
 var visual = create$1('g');
 classes$1(visual).add('djs-visual');
7936
 append(gfx, visual);
7938
 return gfx;
};
7941
GraphicsFactory.prototype.create = function(type, element, parentIndex) {
 var childrenGfx = this._getChildrenContainer(element.parent);
 return this._createContainer(type, childrenGfx, parentIndex, isFrameElement$1(element));
};
7946
GraphicsFactory.prototype.updateContainments = function(elements) {
7948
 var self = this,
     elementRegistry = this._elementRegistry,
     parents;
7952
 parents = reduce(elements, function(map, e) {
7954
   if (e.parent) {
     map[e.parent.id] = e.parent;
   }
7958
   return map;
 }, {});
7961
 // update all parents of changed and reorganized their children
 // in the correct order (as indicated in our model)
 forEach$2(parents, function(parent) {
7965
   var children = parent.children;
7967
   if (!children) {
     return;
   }
7971
   var childrenGfx = self._getChildrenContainer(parent);
7973
   forEach$2(children.slice().reverse(), function(child) {
     var childGfx = elementRegistry.getGraphics(child);
7976
     prependTo(childGfx.parentNode, childrenGfx);
   });
 });
};
7981
GraphicsFactory.prototype.drawShape = function(visual, element) {
 var eventBus = this._eventBus;
7984
 return eventBus.fire('render.shape', { gfx: visual, element: element });
};
7987
GraphicsFactory.prototype.getShapePath = function(element) {
 var eventBus = this._eventBus;
7990
 return eventBus.fire('render.getShapePath', element);
};
7993
GraphicsFactory.prototype.drawConnection = function(visual, element) {
 var eventBus = this._eventBus;
7996
 return eventBus.fire('render.connection', { gfx: visual, element: element });
};
7999
GraphicsFactory.prototype.getConnectionPath = function(waypoints) {
 var eventBus = this._eventBus;
8002
 return eventBus.fire('render.getConnectionPath', waypoints);
};
8005
GraphicsFactory.prototype.update = function(type, element, gfx) {
8007
 // do NOT update root element
 if (!element.parent) {
   return;
 }
8012
 var visual = this._clear(gfx);
8014
 // redraw
 if (type === 'shape') {
   this.drawShape(visual, element);
8018
   // update positioning
   translate$2(gfx, element.x, element.y);
 } else
 if (type === 'connection') {
   this.drawConnection(visual, element);
 } else {
   throw new Error('unknown type: ' + type);
 }
8027
 if (element.hidden) {
   attr$1(gfx, 'display', 'none');
 } else {
   attr$1(gfx, 'display', 'block');
 }
};
8034
GraphicsFactory.prototype.remove = function(element) {
 var gfx = this._elementRegistry.getGraphics(element);
8037
 // remove
 remove$2(gfx.parentNode);
};
8041
8042
// helpers //////////
8044
function prependTo(newNode, parentNode, siblingNode) {
 var node = siblingNode || parentNode.firstChild;
8047
 // do not prepend node to itself to prevent IE from crashing
 // https://github.com/bpmn-io/bpmn-js/issues/746
 if (newNode === node) {
   return;
 }
8053
 parentNode.insertBefore(newNode, node);
}
8056
var CoreModule$1 = {
 __depends__: [ DrawModule$1 ],
 __init__: [ 'canvas' ],
 canvas: [ 'type', Canvas ],
 elementRegistry: [ 'type', ElementRegistry ],
 elementFactory: [ 'type', ElementFactory$1 ],
 eventBus: [ 'type', EventBus ],
 graphicsFactory: [ 'type', GraphicsFactory ]
};
8066
/**
* Bootstrap an injector from a list of modules, instantiating a number of default components
*
* @ignore
* @param {Array<didi.Module>} bootstrapModules
*
* @return {didi.Injector} a injector to use to access the components
*/
function bootstrap(bootstrapModules) {
8076
 var modules = [],
     components = [];
8079
 function hasModule(m) {
   return modules.indexOf(m) >= 0;
 }
8083
 function addModule(m) {
   modules.push(m);
 }
8087
 function visit(m) {
   if (hasModule(m)) {
     return;
   }
8092
   (m.__depends__ || []).forEach(visit);
8094
   if (hasModule(m)) {
     return;
   }
8098
   addModule(m);
8100
   (m.__init__ || []).forEach(function(c) {
     components.push(c);
   });
 }
8105
 bootstrapModules.forEach(visit);
8107
 var injector = new Injector(modules);
8109
 components.forEach(function(c) {
8111
   try {
8113
     // eagerly resolve component (fn or string)
     injector[typeof c === 'string' ? 'get' : 'invoke'](c);
   } catch (e) {
     console.error('Failed to instantiate component');
     console.error(e.stack);
8119
     throw e;
   }
 });
8123
 return injector;
}
8126
/**
* Creates an injector from passed options.
*
* @ignore
* @param  {Object} options
* @return {didi.Injector}
*/
function createInjector(options) {
8135
 options = options || {};
8137
 var configModule = {
   'config': [ 'value', options ]
 };
8141
 var modules = [ configModule, CoreModule$1 ].concat(options.modules || []);
8143
 return bootstrap(modules);
}
8146
8147
/**
* The main diagram-js entry point that bootstraps the diagram with the given
* configuration.
*
* To register extensions with the diagram, pass them as Array<didi.Module> to the constructor.
*
* @class djs.Diagram
* @memberOf djs
* @constructor
*
* @example
*
* <caption>Creating a plug-in that logs whenever a shape is added to the canvas.</caption>
*
* // plug-in implemenentation
* function MyLoggingPlugin(eventBus) {
*   eventBus.on('shape.added', function(event) {
*     console.log('shape ', event.shape, ' was added to the diagram');
*   });
* }
*
* // export as module
* export default {
*   __init__: [ 'myLoggingPlugin' ],
*     myLoggingPlugin: [ 'type', MyLoggingPlugin ]
* };
*
*
* // instantiate the diagram with the new plug-in
*
* import MyLoggingModule from 'path-to-my-logging-plugin';
*
* var diagram = new Diagram({
*   modules: [
*     MyLoggingModule
*   ]
* });
*
* diagram.invoke([ 'canvas', function(canvas) {
*   // add shape to drawing canvas
*   canvas.addShape({ x: 10, y: 10 });
* });
*
* // 'shape ... was added to the diagram' logged to console
*
* @param {Object} options
* @param {Array<didi.Module>} [options.modules] external modules to instantiate with the diagram
* @param {didi.Injector} [injector] an (optional) injector to bootstrap the diagram with
*/
function Diagram(options, injector) {
8198
 // create injector unless explicitly specified
 this.injector = injector = injector || createInjector(options);
8201
 // API
8203
 /**
  * Resolves a diagram service
  *
  * @method Diagram#get
  *
  * @param {string} name the name of the diagram service to be retrieved
  * @param {boolean} [strict=true] if false, resolve missing services to null
  */
 this.get = injector.get;
8213
 /**
  * Executes a function into which diagram services are injected
  *
  * @method Diagram#invoke
  *
  * @param {Function|Object[]} fn the function to resolve
  * @param {Object} locals a number of locals to use to resolve certain dependencies
  */
 this.invoke = injector.invoke;
8223
 // init
8225
 // indicate via event
8227
8228
 /**
  * An event indicating that all plug-ins are loaded.
  *
  * Use this event to fire other events to interested plug-ins
  *
  * @memberOf Diagram
  *
  * @event diagram.init
  *
  * @example
  *
  * eventBus.on('diagram.init', function() {
  *   eventBus.fire('my-custom-event', { foo: 'BAR' });
  * });
  *
  * @type {Object}
  */
 this.get('eventBus').fire('diagram.init');
}
8248
8249
/**
* Destroys the diagram
*
* @method  Diagram#destroy
*/
Diagram.prototype.destroy = function() {
 this.get('eventBus').fire('diagram.destroy');
};
8258
/**
* Clear the diagram, removing all contents.
*/
Diagram.prototype.clear = function() {
 this.get('eventBus').fire('diagram.clear');
};
8265
/**
* Moddle base element.
*/
function Base() { }
8270
Base.prototype.get = function(name) {
 return this.$model.properties.get(this, name);
};
8274
Base.prototype.set = function(name, value) {
 this.$model.properties.set(this, name, value);
};
8278
/**
* A model element factory.
*
* @param {Moddle} model
* @param {Properties} properties
*/
function Factory(model, properties) {
 this.model = model;
 this.properties = properties;
}
8289
8290
Factory.prototype.createType = function(descriptor) {
8292
 var model = this.model;
8294
 var props = this.properties,
     prototype = Object.create(Base.prototype);
8297
 // initialize default values
 forEach$2(descriptor.properties, function(p) {
   if (!p.isMany && p.default !== undefined) {
     prototype[p.name] = p.default;
   }
 });
8304
 props.defineModel(prototype, model);
 props.defineDescriptor(prototype, descriptor);
8307
 var name = descriptor.ns.name;
8309
 /**
  * The new type constructor
  */
 function ModdleElement(attrs) {
   props.define(this, '$type', { value: name, enumerable: true });
   props.define(this, '$attrs', { value: {} });
   props.define(this, '$parent', { writable: true });
8317
   forEach$2(attrs, bind(function(val, key) {
     this.set(key, val);
   }, this));
 }
8322
 ModdleElement.prototype = prototype;
8324
 ModdleElement.hasType = prototype.$instanceOf = this.model.hasType;
8326
 // static links
 props.defineModel(ModdleElement, model);
 props.defineDescriptor(ModdleElement, descriptor);
8330
 return ModdleElement;
};
8333
/**
* Built-in moddle types
*/
var BUILTINS = {
 String: true,
 Boolean: true,
 Integer: true,
 Real: true,
 Element: true
};
8344
/**
* Converters for built in types from string representations
*/
var TYPE_CONVERTERS = {
 String: function(s) { return s; },
 Boolean: function(s) { return s === 'true'; },
 Integer: function(s) { return parseInt(s, 10); },
 Real: function(s) { return parseFloat(s); }
};
8354
/**
* Convert a type to its real representation
*/
function coerceType(type, value) {
8359
 var converter = TYPE_CONVERTERS[type];
8361
 if (converter) {
   return converter(value);
 } else {
   return value;
 }
}
8368
/**
* Return whether the given type is built-in
*/
function isBuiltIn(type) {
 return !!BUILTINS[type];
}
8375
/**
* Return whether the given type is simple
*/
function isSimple(type) {
 return !!TYPE_CONVERTERS[type];
}
8382
/**
* Parses a namespaced attribute name of the form (ns:)localName to an object,
* given a default prefix to assume in case no explicit namespace is given.
*
* @param {String} name
* @param {String} [defaultPrefix] the default prefix to take, if none is present.
*
* @return {Object} the parsed name
*/
function parseName(name, defaultPrefix) {
 var parts = name.split(/:/),
     localName, prefix;
8395
 // no prefix (i.e. only local name)
 if (parts.length === 1) {
   localName = name;
   prefix = defaultPrefix;
 } else
 // prefix + local name
 if (parts.length === 2) {
   localName = parts[1];
   prefix = parts[0];
 } else {
   throw new Error('expected <prefix:localName> or <localName>, got ' + name);
 }
8408
 name = (prefix ? prefix + ':' : '') + localName;
8410
 return {
   name: name,
   prefix: prefix,
   localName: localName
 };
}
8417
/**
* A utility to build element descriptors.
*/
function DescriptorBuilder(nameNs) {
 this.ns = nameNs;
 this.name = nameNs.name;
 this.allTypes = [];
 this.allTypesByName = {};
 this.properties = [];
 this.propertiesByName = {};
}
8429
8430
DescriptorBuilder.prototype.build = function() {
 return pick(this, [
   'ns',
   'name',
   'allTypes',
   'allTypesByName',
   'properties',
   'propertiesByName',
   'bodyProperty',
   'idProperty'
 ]);
};
8443
/**
* Add property at given index.
*
* @param {Object} p
* @param {Number} [idx]
* @param {Boolean} [validate=true]
*/
DescriptorBuilder.prototype.addProperty = function(p, idx, validate) {
8452
 if (typeof idx === 'boolean') {
   validate = idx;
   idx = undefined;
 }
8457
 this.addNamedProperty(p, validate !== false);
8459
 var properties = this.properties;
8461
 if (idx !== undefined) {
   properties.splice(idx, 0, p);
 } else {
   properties.push(p);
 }
};
8468
8469
DescriptorBuilder.prototype.replaceProperty = function(oldProperty, newProperty, replace) {
 var oldNameNs = oldProperty.ns;
8472
 var props = this.properties,
     propertiesByName = this.propertiesByName,
     rename = oldProperty.name !== newProperty.name;
8476
 if (oldProperty.isId) {
   if (!newProperty.isId) {
     throw new Error(
       'property <' + newProperty.ns.name + '> must be id property ' +
       'to refine <' + oldProperty.ns.name + '>');
   }
8483
   this.setIdProperty(newProperty, false);
 }
8486
 if (oldProperty.isBody) {
8488
   if (!newProperty.isBody) {
     throw new Error(
       'property <' + newProperty.ns.name + '> must be body property ' +
       'to refine <' + oldProperty.ns.name + '>');
   }
8494
   // TODO: Check compatibility
   this.setBodyProperty(newProperty, false);
 }
8498
 // validate existence and get location of old property
 var idx = props.indexOf(oldProperty);
 if (idx === -1) {
   throw new Error('property <' + oldNameNs.name + '> not found in property list');
 }
8504
 // remove old property
 props.splice(idx, 1);
8507
 // replacing the named property is intentional
 //
 //  * validate only if this is a "rename" operation
 //  * add at specific index unless we "replace"
 //
 this.addProperty(newProperty, replace ? undefined : idx, rename);
8514
 // make new property available under old name
 propertiesByName[oldNameNs.name] = propertiesByName[oldNameNs.localName] = newProperty;
};
8518
8519
DescriptorBuilder.prototype.redefineProperty = function(p, targetPropertyName, replace) {
8521
 var nsPrefix = p.ns.prefix;
 var parts = targetPropertyName.split('#');
8524
 var name = parseName(parts[0], nsPrefix);
 var attrName = parseName(parts[1], name.prefix).name;
8527
 var redefinedProperty = this.propertiesByName[attrName];
 if (!redefinedProperty) {
   throw new Error('refined property <' + attrName + '> not found');
 } else {
   this.replaceProperty(redefinedProperty, p, replace);
 }
8534
 delete p.redefines;
};
8537
DescriptorBuilder.prototype.addNamedProperty = function(p, validate) {
 var ns = p.ns,
     propsByName = this.propertiesByName;
8541
 if (validate) {
   this.assertNotDefined(p, ns.name);
   this.assertNotDefined(p, ns.localName);
 }
8546
 propsByName[ns.name] = propsByName[ns.localName] = p;
};
8549
DescriptorBuilder.prototype.removeNamedProperty = function(p) {
 var ns = p.ns,
     propsByName = this.propertiesByName;
8553
 delete propsByName[ns.name];
 delete propsByName[ns.localName];
};
8557
DescriptorBuilder.prototype.setBodyProperty = function(p, validate) {
8559
 if (validate && this.bodyProperty) {
   throw new Error(
     'body property defined multiple times ' +
     '(<' + this.bodyProperty.ns.name + '>, <' + p.ns.name + '>)');
 }
8565
 this.bodyProperty = p;
};
8568
DescriptorBuilder.prototype.setIdProperty = function(p, validate) {
8570
 if (validate && this.idProperty) {
   throw new Error(
     'id property defined multiple times ' +
     '(<' + this.idProperty.ns.name + '>, <' + p.ns.name + '>)');
 }
8576
 this.idProperty = p;
};
8579
DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
 var propertyName = p.name,
     definedProperty = this.propertiesByName[propertyName];
8583
 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');
 }
};
8591
DescriptorBuilder.prototype.hasProperty = function(name) {
 return this.propertiesByName[name];
};
8595
DescriptorBuilder.prototype.addTrait = function(t, inherited) {
8597
 var typesByName = this.allTypesByName,
     types = this.allTypes;
8600
 var typeName = t.name;
8602
 if (typeName in typesByName) {
   return;
 }
8606
 forEach$2(t.properties, bind(function(p) {
8608
   // clone property to allow extensions
   p = assign({}, p, {
     name: p.ns.localName,
     inherited: inherited
   });
8614
   Object.defineProperty(p, 'definedBy', {
     value: t
   });
8618
   var replaces = p.replaces,
       redefines = p.redefines;
8621
   // 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));
8635
 types.push(t);
 typesByName[typeName] = t;
};
8639
/**
* A registry of Moddle packages.
*
* @param {Array<Package>} packages
* @param {Properties} properties
*/
function Registry(packages, properties) {
 this.packageMap = {};
 this.typeMap = {};
8649
 this.packages = [];
8651
 this.properties = properties;
8653
 forEach$2(packages, bind(this.registerPackage, this));
}
8656
8657
Registry.prototype.getPackage = function(uriOrPrefix) {
 return this.packageMap[uriOrPrefix];
};
8661
Registry.prototype.getPackages = function() {
 return this.packages;
};
8665
8666
Registry.prototype.registerPackage = function(pkg) {
8668
 // copy package
 pkg = assign({}, pkg);
8671
 var pkgMap = this.packageMap;
8673
 ensureAvailable(pkgMap, pkg, 'prefix');
 ensureAvailable(pkgMap, pkg, 'uri');
8676
 // register types
 forEach$2(pkg.types, bind(function(descriptor) {
   this.registerType(descriptor, pkg);
 }, this));
8681
 pkgMap[pkg.uri] = pkgMap[pkg.prefix] = pkg;
 this.packages.push(pkg);
};
8685
8686
/**
* Register a type from a specific package with us
*/
Registry.prototype.registerType = function(type, pkg) {
8691
 type = assign({}, type, {
   superClass: (type.superClass || []).slice(),
   extends: (type.extends || []).slice(),
   properties: (type.properties || []).slice(),
   meta: assign((type.meta || {}))
 });
8698
 var ns = parseName(type.name, pkg.prefix),
     name = ns.name,
     propertiesByName = {};
8702
 // parse properties
 forEach$2(type.properties, bind(function(p) {
8705
   // namespace property names
   var propertyNs = parseName(p.name, ns.prefix),
       propertyName = propertyNs.name;
8709
   // namespace property types
   if (!isBuiltIn(p.type)) {
     p.type = parseName(p.type, propertyNs.prefix).name;
   }
8714
   assign(p, {
     ns: propertyNs,
     name: propertyName
   });
8719
   propertiesByName[propertyName] = p;
 }, this));
8722
 // update ns + name
 assign(type, {
   ns: ns,
   name: name,
   propertiesByName: propertiesByName
 });
8729
 forEach$2(type.extends, bind(function(extendsName) {
   var extended = this.typeMap[extendsName];
8732
   extended.traits = extended.traits || [];
   extended.traits.push(name);
 }, this));
8736
 // link to package
 this.definePackage(type, pkg);
8739
 // register
 this.typeMap[name] = type;
};
8743
8744
/**
* 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) {
8755
 var type = isBuiltIn(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];
8757
 var self = this;
8759
 /**
  * Traverse the selected trait.
  *
  * @param {String} cls
  */
 function traverseTrait(cls) {
   return traverseSuper(cls, true);
 }
8768
 /**
  * Traverse the selected super type or trait
  *
  * @param {String} cls
  * @param {Boolean} [trait=false]
  */
 function traverseSuper(cls, trait) {
   var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
   self.mapTypes(parentNs, iterator, trait);
 }
8779
 if (!type) {
   throw new Error('unknown type <' + nsName.name + '>');
 }
8783
 forEach$2(type.superClass, trait ? traverseTrait : traverseSuper);
8785
 // call iterator with (type, inherited=!trait)
 iterator(type, !trait);
8788
 forEach$2(type.traits, traverseTrait);
};
8791
8792
/**
* 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) {
8801
 var nsName = parseName(name);
8803
 var builder = new DescriptorBuilder(nsName);
8805
 this.mapTypes(nsName, function(type, inherited) {
   builder.addTrait(type, inherited);
 });
8809
 var descriptor = builder.build();
8811
 // define package link
 this.definePackage(descriptor, descriptor.allTypes[descriptor.allTypes.length - 1].$pkg);
8814
 return descriptor;
};
8817
8818
Registry.prototype.definePackage = function(target, pkg) {
 this.properties.define(target, '$pkg', { value: pkg });
};
8822
8823
8824
///////// helpers ////////////////////////////
8826
function ensureAvailable(packageMap, pkg, identifierKey) {
8828
 var value = pkg[identifierKey];
8830
 if (value in packageMap) {
   throw new Error('package with ' + identifierKey + ' <' + value + '> already defined');
 }
}
8835
/**
* A utility that gets and sets properties of model elements.
*
* @param {Model} model
*/
function Properties(model) {
 this.model = model;
}
8844
8845
/**
* 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) {
8855
 var property = this.model.getPropertyDescriptor(target, name);
8857
 var propertyName = property && property.name;
8859
 if (isUndefined(value)) {
   // 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[name];
   }
 } else {
   // 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[name] = value;
   }
 }
};
8882
/**
* Returns the named property of the given element
*
* @param  {Object} target
* @param  {String} name
*
* @return {Object}
*/
Properties.prototype.get = function(target, name) {
8892
 var property = this.model.getPropertyDescriptor(target, name);
8894
 if (!property) {
   return target.$attrs[name];
 }
8898
 var propertyName = property.name;
8900
 // check if access to collection property and lazily initialize it
 if (!target[propertyName] && property.isMany) {
   defineProperty(target, property, []);
 }
8905
 return target[propertyName];
};
8908
8909
/**
* Define a property on the target element
*
* @param  {Object} target
* @param  {String} name
* @param  {Object} options
*/
Properties.prototype.define = function(target, name, options) {
 Object.defineProperty(target, name, options);
};
8920
8921
/**
* Define the descriptor for an element
*/
Properties.prototype.defineDescriptor = function(target, descriptor) {
 this.define(target, '$descriptor', { value: descriptor });
};
8928
/**
* Define the model for an element
*/
Properties.prototype.defineModel = function(target, model) {
 this.define(target, '$model', { value: model });
};
8935
8936
function isUndefined(val) {
 return typeof val === 'undefined';
}
8940
function defineProperty(target, property, value) {
 Object.defineProperty(target, property.name, {
   enumerable: !property.isReference,
   writable: true,
   value: value,
   configurable: true
 });
}
8949
//// Moddle implementation /////////////////////////////////////////////////
8951
/**
* @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]);
*
* @param {Array<Package>} packages the packages to contain
*/
function Moddle(packages) {
8974
 this.properties = new Properties(this);
8976
 this.factory = new Factory(this, this.properties);
 this.registry = new Registry(packages, this.properties);
8979
 this.typeCache = {};
}
8982
8983
/**
* 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);
9000
 if (!Type) {
   throw new Error('unknown type <' + descriptor + '>');
 }
9004
 return new Type(attrs);
};
9007
9008
/**
* Returns the type representing a given descriptor
*
* @method Moddle#getType
*
* @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
*/
Moddle.prototype.getType = function(descriptor) {
9023
 var cache = this.typeCache;
9025
 var name = isString(descriptor) ? descriptor : descriptor.ns.name;
9027
 var type = cache[name];
9029
 if (!type) {
   descriptor = this.registry.getEffectiveDescriptor(name);
   type = cache[name] = this.factory.createType(descriptor);
 }
9034
 return type;
};
9037
9038
/**
* 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) {
9067
 var nameNs = parseName(name);
9069
 var element = {
   $type: name,
   $instanceOf: function(type) {
     return type === this.$type;
   }
 };
9076
 var descriptor = {
   name: name,
   isGeneric: true,
   ns: {
     prefix: nameNs.prefix,
     localName: nameNs.localName,
     uri: nsUri
   }
 };
9086
 this.properties.defineDescriptor(element, descriptor);
 this.properties.defineModel(element, this);
 this.properties.define(element, '$parent', { enumerable: false, writable: true });
 this.properties.define(element, '$instanceOf', { enumerable: false, writable: true });
9091
 forEach$2(properties, function(a, key) {
   if (isObject(a) && a.value !== undefined) {
     element[a.name] = a.value;
   } else {
     element[key] = a;
   }
 });
9099
 return element;
};
9102
/**
* Returns a registered package by uri or prefix
*
* @return {Object} the package
*/
Moddle.prototype.getPackage = function(uriOrPrefix) {
 return this.registry.getPackage(uriOrPrefix);
};
9111
/**
* Returns a snapshot of all known packages
*
* @return {Object} the package
*/
Moddle.prototype.getPackages = function() {
 return this.registry.getPackages();
};
9120
/**
* Returns the descriptor for an element
*/
Moddle.prototype.getElementDescriptor = function(element) {
 return element.$descriptor;
};
9127
/**
* Returns true if the given descriptor or instance
* represents the given type.
*
* May be applied to this, if element is omitted.
*/
Moddle.prototype.hasType = function(element, type) {
 if (type === undefined) {
   type = element;
   element = this;
 }
9139
 var descriptor = element.$model.getElementDescriptor(element);
9141
 return (type in descriptor.allTypesByName);
};
9144
/**
* Returns the descriptor of an elements named property
*/
Moddle.prototype.getPropertyDescriptor = function(element, property) {
 return this.getElementDescriptor(element).propertiesByName[property];
};
9151
/**
* Returns a mapped type's descriptor
*/
Moddle.prototype.getTypeDescriptor = function(type) {
 return this.registry.typeMap[type];
};
9158
var fromCharCode = String.fromCharCode;
9160
var hasOwnProperty = Object.prototype.hasOwnProperty;
9162
var ENTITY_PATTERN = /&#(\d+);|&#x([0-9a-f]+);|&(\w+);/ig;
9164
var ENTITY_MAPPING = {
 'amp': '&',
 'apos': '\'',
 'gt': '>',
 'lt': '<',
 'quot': '"'
};
9172
// map UPPERCASE variants of supported special chars
Object.keys(ENTITY_MAPPING).forEach(function(k) {
 ENTITY_MAPPING[k.toUpperCase()] = ENTITY_MAPPING[k];
});
9177
9178
function replaceEntities(_, d, x, z) {
9180
 // reserved names, i.e. &nbsp;
 if (z) {
   if (hasOwnProperty.call(ENTITY_MAPPING, z)) {
     return ENTITY_MAPPING[z];
   } else {
9186
     // fall back to original value
     return '&' + z + ';';
   }
 }
9191
 // decimal encoded char
 if (d) {
   return fromCharCode(d);
 }
9196
 // hex encoded char
 return fromCharCode(parseInt(x, 16));
}
9200
9201
/**
* A basic entity decoder that can decode a minimal
* sub-set of reserved names (&amp;) as well as
* hex (&#xaaf;) and decimal (&#1231;) encoded characters.
*
* @param {string} str
*
* @return {string} decoded string
*/
function decodeEntities(s) {
 if (s.length > 3 && s.indexOf('&') !== -1) {
   return s.replace(ENTITY_PATTERN, replaceEntities);
 }
9215
 return s;
}
9218
var XSI_URI = 'http://www.w3.org/2001/XMLSchema-instance';
var XSI_PREFIX = 'xsi';
var XSI_TYPE$1 = 'xsi:type';
9222
var NON_WHITESPACE_OUTSIDE_ROOT_NODE = 'non-whitespace outside of root node';
9224
function error$2(msg) {
 return new Error(msg);
}
9228
function missingNamespaceForPrefix(prefix) {
 return 'missing namespace for prefix <' + prefix + '>';
}
9232
function getter(getFn) {
 return {
   'get': getFn,
   'enumerable': true
 };
}
9239
function cloneNsMatrix(nsMatrix) {
 var clone = {}, key;
 for (key in nsMatrix) {
   clone[key] = nsMatrix[key];
 }
 return clone;
}
9247
function uriPrefix(prefix) {
 return prefix + '$uri';
}
9251
function buildNsMatrix(nsUriToPrefix) {
 var nsMatrix = {},
     uri,
     prefix;
9256
 for (uri in nsUriToPrefix) {
   prefix = nsUriToPrefix[uri];
   nsMatrix[prefix] = prefix;
   nsMatrix[uriPrefix(prefix)] = uri;
 }
9262
 return nsMatrix;
}
9265
function noopGetContext() {
 return { 'line': 0, 'column': 0 };
}
9269
function throwFunc(err) {
 throw err;
}
9273
/**
* Creates a new parser with the given options.
*
* @constructor
*
* @param  {!Object<string, ?>=} options
*/
function Parser(options) {
9282
 if (!this) {
   return new Parser(options);
 }
9286
 var proxy = options && options['proxy'];
9288
 var onText,
     onOpenTag,
     onCloseTag,
     onCDATA,
     onError = throwFunc,
     onWarning,
     onComment,
     onQuestion,
     onAttention;
9298
 var getContext = noopGetContext;
9300
 /**
  * Do we need to parse the current elements attributes for namespaces?
  *
  * @type {boolean}
  */
 var maybeNS = false;
9307
 /**
  * Do we process namespaces at all?
  *
  * @type {boolean}
  */
 var isNamespace = false;
9314
 /**
  * The caught error returned on parse end
  *
  * @type {Error}
  */
 var returnError = null;
9321
 /**
  * Should we stop parsing?
  *
  * @type {boolean}
  */
 var parseStop = false;
9328
 /**
  * A map of { uri: prefix } used by the parser.
  *
  * This map will ensure we can normalize prefixes during processing;
  * for each uri, only one prefix will be exposed to the handlers.
  *
  * @type {!Object<string, string>}}
  */
 var nsUriToPrefix;
9338
 /**
  * Handle parse error.
  *
  * @param  {string|Error} err
  */
 function handleError(err) {
   if (!(err instanceof Error)) {
     err = error$2(err);
   }
9348
   returnError = err;
9350
   onError(err, getContext);
 }
9353
 /**
  * Handle parse error.
  *
  * @param  {string|Error} err
  */
 function handleWarning(err) {
9360
   if (!onWarning) {
     return;
   }
9364
   if (!(err instanceof Error)) {
     err = error$2(err);
   }
9368
   onWarning(err, getContext);
 }
9371
 /**
  * Register parse listener.
  *
  * @param  {string}   name
  * @param  {Function} cb
  *
  * @return {Parser}
  */
 this['on'] = function(name, cb) {
9381
   if (typeof cb !== 'function') {
     throw error$2('required args <name, cb>');
   }
9385
   switch (name) {
   case 'openTag': onOpenTag = cb; break;
   case 'text': onText = cb; break;
   case 'closeTag': onCloseTag = cb; break;
   case 'error': onError = cb; break;
   case 'warn': onWarning = cb; break;
   case 'cdata': onCDATA = cb; break;
   case 'attention': onAttention = cb; break; // <!XXXXX zzzz="eeee">
   case 'question': onQuestion = cb; break; // <? ....  ?>
   case 'comment': onComment = cb; break;
   default:
     throw error$2('unsupported event: ' + name);
   }
9399
   return this;
 };
9402
 /**
  * Set the namespace to prefix mapping.
  *
  * @example
  *
  * parser.ns({
  *   'http://foo': 'foo',
  *   'http://bar': 'bar'
  * });
  *
  * @param  {!Object<string, string>} nsMap
  *
  * @return {Parser}
  */
 this['ns'] = function(nsMap) {
9418
   if (typeof nsMap === 'undefined') {
     nsMap = {};
   }
9422
   if (typeof nsMap !== 'object') {
     throw error$2('required args <nsMap={}>');
   }
9426
   var _nsUriToPrefix = {}, k;
9428
   for (k in nsMap) {
     _nsUriToPrefix[k] = nsMap[k];
   }
9432
   // FORCE default mapping for schema instance
   _nsUriToPrefix[XSI_URI] = XSI_PREFIX;
9435
   isNamespace = true;
   nsUriToPrefix = _nsUriToPrefix;
9438
   return this;
 };
9441
 /**
  * Parse xml string.
  *
  * @param  {string} xml
  *
  * @return {Error} returnError, if not thrown
  */
 this['parse'] = function(xml) {
   if (typeof xml !== 'string') {
     throw error$2('required args <xml=string>');
   }
9453
   returnError = null;
9455
   parse(xml);
9457
   getContext = noopGetContext;
   parseStop = false;
9460
   return returnError;
 };
9463
 /**
  * Stop parsing.
  */
 this['stop'] = function() {
   parseStop = true;
 };
9470
 /**
  * Parse string, invoking configured listeners on element.
  *
  * @param  {string} xml
  */
 function parse(xml) {
   var nsMatrixStack = isNamespace ? [] : null,
       nsMatrix = isNamespace ? buildNsMatrix(nsUriToPrefix) : null,
       _nsMatrix,
       nodeStack = [],
       anonymousNsCount = 0,
       tagStart = false,
       tagEnd = false,
       i = 0, j = 0,
       x, y, q, w, v,
       xmlns,
       elementName,
       _elementName,
       elementProxy
       ;
9491
   var attrsString = '',
       attrsStart = 0,
       cachedAttrs // false = parsed with errors, null = needs parsing
       ;
9496
   /**
    * Parse attributes on demand and returns the parsed attributes.
    *
    * Return semantics: (1) `false` on attribute parse error,
    * (2) object hash on extracted attrs.
    *
    * @return {boolean|Object}
    */
   function getAttrs() {
     if (cachedAttrs !== null) {
       return cachedAttrs;
     }
9509
     var nsUri,
         nsUriPrefix,
         nsName,
         defaultAlias = isNamespace && nsMatrix['xmlns'],
         attrList = isNamespace && maybeNS ? [] : null,
         i = attrsStart,
         s = attrsString,
         l = s.length,
         hasNewMatrix,
         newalias,
         value,
         alias,
         name,
         attrs = {},
         seenAttrs = {},
         skipAttr,
         w,
         j;
9528
     parseAttr:
     for (; i < l; i++) {
       skipAttr = false;
       w = s.charCodeAt(i);
9533
       if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE={ \f\n\r\t\v}
         continue;
       }
9537
       // wait for non whitespace character
       if (w < 65 || w > 122 || (w > 90 && w < 97)) {
         if (w !== 95 && w !== 58) { // char 95"_" 58":"
           handleWarning('illegal first char attribute name');
           skipAttr = true;
         }
       }
9545
       // parse attribute name
       for (j = i + 1; j < l; j++) {
         w = s.charCodeAt(j);
9549
         if (
           w > 96 && w < 123 ||
           w > 64 && w < 91 ||
           w > 47 && w < 59 ||
           w === 46 || // '.'
           w === 45 || // '-'
           w === 95 // '_'
         ) {
           continue;
         }
9560
         // unexpected whitespace
         if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE
           handleWarning('missing attribute value');
           i = j;
9565
           continue parseAttr;
         }
9568
         // expected "="
         if (w === 61) { // "=" == 61
           break;
         }
9573
         handleWarning('illegal attribute name char');
         skipAttr = true;
       }
9577
       name = s.substring(i, j);
9579
       if (name === 'xmlns:xmlns') {
         handleWarning('illegal declaration of xmlns');
         skipAttr = true;
       }
9584
       w = s.charCodeAt(j + 1);
9586
       if (w === 34) { // '"'
         j = s.indexOf('"', i = j + 2);
9589
         if (j === -1) {
           j = s.indexOf('\'', i);
9592
           if (j !== -1) {
             handleWarning('attribute value quote missmatch');
             skipAttr = true;
           }
         }
9598
       } else if (w === 39) { // "'"
         j = s.indexOf('\'', i = j + 2);
9601
         if (j === -1) {
           j = s.indexOf('"', i);
9604
           if (j !== -1) {
             handleWarning('attribute value quote missmatch');
             skipAttr = true;
           }
         }
9610
       } else {
         handleWarning('missing attribute value quotes');
         skipAttr = true;
9614
         // skip to next space
         for (j = j + 1; j < l; j++) {
           w = s.charCodeAt(j + 1);
9618
           if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE
             break;
           }
         }
9623
       }
9625
       if (j === -1) {
         handleWarning('missing closing quotes');
9628
         j = l;
         skipAttr = true;
       }
9632
       if (!skipAttr) {
         value = s.substring(i, j);
       }
9636
       i = j;
9638
       // ensure SPACE follows attribute
       // skip illegal content otherwise
       // example a="b"c
       for (; j + 1 < l; j++) {
         w = s.charCodeAt(j + 1);
9644
         if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE
           break;
         }
9648
         // FIRST ILLEGAL CHAR
         if (i === j) {
           handleWarning('illegal character after attribute end');
           skipAttr = true;
         }
       }
9655
       // advance cursor to next attribute
       i = j + 1;
9658
       if (skipAttr) {
         continue parseAttr;
       }
9662
       // check attribute re-declaration
       if (name in seenAttrs) {
         handleWarning('attribute <' + name + '> already defined');
         continue;
       }
9668
       seenAttrs[name] = true;
9670
       if (!isNamespace) {
         attrs[name] = value;
         continue;
       }
9675
       // try to extract namespace information
       if (maybeNS) {
         newalias = (
           name === 'xmlns'
             ? 'xmlns'
             : (name.charCodeAt(0) === 120 && name.substr(0, 6) === 'xmlns:')
               ? name.substr(6)
               : null
         );
9685
         // handle xmlns(:alias) assignment
         if (newalias !== null) {
           nsUri = decodeEntities(value);
           nsUriPrefix = uriPrefix(newalias);
9690
           alias = nsUriToPrefix[nsUri];
9692
           if (!alias) {
9694
             // no prefix defined or prefix collision
             if (
               (newalias === 'xmlns') ||
               (nsUriPrefix in nsMatrix && nsMatrix[nsUriPrefix] !== nsUri)
             ) {
9700
               // alocate free ns prefix
               do {
                 alias = 'ns' + (anonymousNsCount++);
               } while (typeof nsMatrix[alias] !== 'undefined');
             } else {
               alias = newalias;
             }
9708
             nsUriToPrefix[nsUri] = alias;
           }
9711
           if (nsMatrix[newalias] !== alias) {
             if (!hasNewMatrix) {
               nsMatrix = cloneNsMatrix(nsMatrix);
               hasNewMatrix = true;
             }
9717
             nsMatrix[newalias] = alias;
             if (newalias === 'xmlns') {
               nsMatrix[uriPrefix(alias)] = nsUri;
               defaultAlias = alias;
             }
9723
             nsMatrix[nsUriPrefix] = nsUri;
           }
9726
           // expose xmlns(:asd)="..." in attributes
           attrs[name] = value;
           continue;
         }
9731
         // collect attributes until all namespace
         // declarations are processed
         attrList.push(name, value);
         continue;
9736
       } /** end if (maybeNs) */
9738
       // handle attributes on element without
       // namespace declarations
       w = name.indexOf(':');
       if (w === -1) {
         attrs[name] = value;
         continue;
       }
9746
       // normalize ns attribute name
       if (!(nsName = nsMatrix[name.substring(0, w)])) {
         handleWarning(missingNamespaceForPrefix(name.substring(0, w)));
         continue;
       }
9752
       name = defaultAlias === nsName
         ? name.substr(w + 1)
         : nsName + name.substr(w);
9756
       // end: normalize ns attribute name
9758
       // normalize xsi:type ns attribute value
       if (name === XSI_TYPE$1) {
         w = value.indexOf(':');
9762
         if (w !== -1) {
           nsName = value.substring(0, w);
9765
           // handle default prefixes, i.e. xs:String gracefully
           nsName = nsMatrix[nsName] || nsName;
           value = nsName + value.substring(w);
         } else {
           value = defaultAlias + ':' + value;
         }
       }
9773
       // end: normalize xsi:type ns attribute value
9775
       attrs[name] = value;
     }
9778
9779
     // handle deferred, possibly namespaced attributes
     if (maybeNS) {
9782
       // normalize captured attributes
       for (i = 0, l = attrList.length; i < l; i++) {
9785
         name = attrList[i++];
         value = attrList[i];
9788
         w = name.indexOf(':');
9790
         if (w !== -1) {
9792
           // normalize ns attribute name
           if (!(nsName = nsMatrix[name.substring(0, w)])) {
             handleWarning(missingNamespaceForPrefix(name.substring(0, w)));
             continue;
           }
9798
           name = defaultAlias === nsName
             ? name.substr(w + 1)
             : nsName + name.substr(w);
9802
           // end: normalize ns attribute name
9804
           // normalize xsi:type ns attribute value
           if (name === XSI_TYPE$1) {
             w = value.indexOf(':');
9808
             if (w !== -1) {
               nsName = value.substring(0, w);
9811
               // handle default prefixes, i.e. xs:String gracefully
               nsName = nsMatrix[nsName] || nsName;
               value = nsName + value.substring(w);
             } else {
               value = defaultAlias + ':' + value;
             }
           }
9819
           // end: normalize xsi:type ns attribute value
         }
9822
         attrs[name] = value;
       }
9825
       // end: normalize captured attributes
     }
9828
     return cachedAttrs = attrs;
   }
9831
   /**
    * Extract the parse context { line, column, part }
    * from the current parser position.
    *
    * @return {Object} parse context
    */
   function getParseContext() {
     var splitsRe = /(\r\n|\r|\n)/g;
9840
     var line = 0;
     var column = 0;
     var startOfLine = 0;
     var endOfLine = j;
     var match;
     var data;
9847
     while (i >= startOfLine) {
9849
       match = splitsRe.exec(xml);
9851
       if (!match) {
         break;
       }
9855
       // end of line = (break idx + break chars)
       endOfLine = match[0].length + match.index;
9858
       if (endOfLine > i) {
         break;
       }
9862
       // advance to next line
       line += 1;
9865
       startOfLine = endOfLine;
     }
9868
     // EOF errors
     if (i == -1) {
       column = endOfLine;
       data = xml.substring(j);
     } else
9874
     // start errors
     if (j === 0) {
       data = xml.substring(j, i);
     }
9879
     // other errors
     else {
       column = i - startOfLine;
       data = (j == -1 ? xml.substring(i) : xml.substring(i, j + 1));
     }
9885
     return {
       'data': data,
       'line': line,
       'column': column
     };
   }
9892
   getContext = getParseContext;
9894
9895
   if (proxy) {
     elementProxy = Object.create({}, {
       'name': getter(function() {
         return elementName;
       }),
       'originalName': getter(function() {
         return _elementName;
       }),
       'attrs': getter(getAttrs),
       'ns': getter(function() {
         return nsMatrix;
       })
     });
   }
9910
   // actual parse logic
   while (j !== -1) {
9913
     if (xml.charCodeAt(j) === 60) { // "<"
       i = j;
     } else {
       i = xml.indexOf('<', j);
     }
9919
     // parse end
     if (i === -1) {
       if (nodeStack.length) {
         return handleError('unexpected end of file');
       }
9925
       if (j === 0) {
         return handleError('missing start tag');
       }
9929
       if (j < xml.length) {
         if (xml.substring(j).trim()) {
           handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);
         }
       }
9935
       return;
     }
9938
     // parse text
     if (j !== i) {
9941
       if (nodeStack.length) {
         if (onText) {
           onText(xml.substring(j, i), decodeEntities, getContext);
9945
           if (parseStop) {
             return;
           }
         }
       } else {
         if (xml.substring(j, i).trim()) {
           handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);
9953
           if (parseStop) {
             return;
           }
         }
       }
     }
9960
     w = xml.charCodeAt(i+1);
9962
     // parse comments + CDATA
     if (w === 33) { // "!"
       q = xml.charCodeAt(i+2);
9966
       // CDATA section
       if (q === 91 && xml.substr(i + 3, 6) === 'CDATA[') { // 91 == "["
         j = xml.indexOf(']]>', i);
         if (j === -1) {
           return handleError('unclosed cdata');
         }
9973
         if (onCDATA) {
           onCDATA(xml.substring(i + 9, j), getContext);
           if (parseStop) {
             return;
           }
         }
9980
         j += 3;
         continue;
       }
9984
       // comment
       if (q === 45 && xml.charCodeAt(i + 3) === 45) { // 45 == "-"
         j = xml.indexOf('-->', i);
         if (j === -1) {
           return handleError('unclosed comment');
         }
9991
9992
         if (onComment) {
           onComment(xml.substring(i + 4, j), decodeEntities, getContext);
           if (parseStop) {
             return;
           }
         }
9999
         j += 3;
         continue;
       }
     }
10004
     // parse question <? ... ?>
     if (w === 63) { // "?"
       j = xml.indexOf('?>', i);
       if (j === -1) {
         return handleError('unclosed question');
       }
10011
       if (onQuestion) {
         onQuestion(xml.substring(i, j + 2), getContext);
         if (parseStop) {
           return;
         }
       }
10018
       j += 2;
       continue;
     }
10022
     // find matching closing tag for attention or standard tags
     // for that we must skip through attribute values
     // (enclosed in single or double quotes)
     for (x = i + 1; ; x++) {
       v = xml.charCodeAt(x);
       if (isNaN(v)) {
         j = -1;
         return handleError('unclosed tag');
       }
10032
       // [10] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'"
       // skips the quoted string
       // (double quotes) does not appear in a literal enclosed by (double quotes)
       // (single quote) does not appear in a literal enclosed by (single quote)
       if (v === 34) { //  '"'
         q = xml.indexOf('"', x + 1);
         x = q !== -1 ? q : x;
       } else if (v === 39) { // "'"
         q = xml.indexOf("'", x + 1);
         x = q !== -1 ? q : x;
       } else if (v === 62) { // '>'
         j = x;
         break;
       }
     }
10048
10049
     // parse attention <! ...>
     // previously comment and CDATA have already been parsed
     if (w === 33) { // "!"
10053
       if (onAttention) {
         onAttention(xml.substring(i, j + 1), decodeEntities, getContext);
         if (parseStop) {
           return;
         }
       }
10060
       j += 1;
       continue;
     }
10064
     // don't process attributes;
     // there are none
     cachedAttrs = {};
10068
     // if (xml.charCodeAt(i+1) === 47) { // </...
     if (w === 47) { // </...
       tagStart = false;
       tagEnd = true;
10073
       if (!nodeStack.length) {
         return handleError('missing open tag');
       }
10077
       // verify open <-> close tag match
       x = elementName = nodeStack.pop();
       q = i + 2 + x.length;
10081
       if (xml.substring(i + 2, q) !== x) {
         return handleError('closing tag mismatch');
       }
10085
       // verify chars in close tag
       for (; q < j; q++) {
         w = xml.charCodeAt(q);
10089
         if (w === 32 || (w > 8 && w < 14)) { // \f\n\r\t\v space
           continue;
         }
10093
         return handleError('close tag');
       }
10096
     } else {
       if (xml.charCodeAt(j - 1) === 47) { // .../>
         x = elementName = xml.substring(i + 1, j - 1);
10100
         tagStart = true;
         tagEnd = true;
10103
       } else {
         x = elementName = xml.substring(i + 1, j);
10106
         tagStart = true;
         tagEnd = false;
       }
10110
       if (!(w > 96 && w < 123 || w > 64 && w < 91 || w === 95 || w === 58)) { // char 95"_" 58":"
         return handleError('illegal first char nodeName');
       }
10114
       for (q = 1, y = x.length; q < y; q++) {
         w = x.charCodeAt(q);
10117
         if (w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 45 || w === 95 || w == 46) {
           continue;
         }
10121
         if (w === 32 || (w < 14 && w > 8)) { // \f\n\r\t\v space
           elementName = x.substring(0, q);
10124
           // maybe there are attributes
           cachedAttrs = null;
           break;
         }
10129
         return handleError('invalid nodeName');
       }
10132
       if (!tagEnd) {
         nodeStack.push(elementName);
       }
     }
10137
     if (isNamespace) {
10139
       _nsMatrix = nsMatrix;
10141
       if (tagStart) {
10143
         // remember old namespace
         // unless we're self-closing
         if (!tagEnd) {
           nsMatrixStack.push(_nsMatrix);
         }
10149
         if (cachedAttrs === null) {
10151
           // quick check, whether there may be namespace
           // declarations on the node; if that is the case
           // we need to eagerly parse the node attributes
           if ((maybeNS = x.indexOf('xmlns', q) !== -1)) {
             attrsStart = q;
             attrsString = x;
10158
             getAttrs();
10160
             maybeNS = false;
           }
         }
       }
10165
       _elementName = elementName;
10167
       w = elementName.indexOf(':');
       if (w !== -1) {
         xmlns = nsMatrix[elementName.substring(0, w)];
10171
         // prefix given; namespace must exist
         if (!xmlns) {
           return handleError('missing namespace on <' + _elementName + '>');
         }
10176
         elementName = elementName.substr(w + 1);
       } else {
         xmlns = nsMatrix['xmlns'];
10180
         // if no default namespace is defined,
         // we'll import the element as anonymous.
         //
         // it is up to users to correct that to the document defined
         // targetNamespace, or whatever their undersanding of the
         // XML spec mandates.
       }
10188
       // adjust namespace prefixs as configured
       if (xmlns) {
         elementName = xmlns + ':' + elementName;
       }
10193
     }
10195
     if (tagStart) {
       attrsStart = q;
       attrsString = x;
10199
       if (onOpenTag) {
         if (proxy) {
           onOpenTag(elementProxy, decodeEntities, tagEnd, getContext);
         } else {
           onOpenTag(elementName, getAttrs, decodeEntities, tagEnd, getContext);
         }
10206
         if (parseStop) {
           return;
         }
       }
10211
     }
10213
     if (tagEnd) {
10215
       if (onCloseTag) {
         onCloseTag(proxy ? elementProxy : elementName, decodeEntities, tagStart, getContext);
10218
         if (parseStop) {
           return;
         }
       }
10223
       // restore old namespace
       if (isNamespace) {
         if (!tagStart) {
           nsMatrix = nsMatrixStack.pop();
         } else {
           nsMatrix = _nsMatrix;
         }
       }
     }
10233
     j += 1;
   }
 } /** end parse */
10237
}
10239
function hasLowerCaseAlias(pkg) {
 return pkg.xml && pkg.xml.tagAlias === 'lowerCase';
}
10243
var DEFAULT_NS_MAP = {
 'xsi': 'http://www.w3.org/2001/XMLSchema-instance',
 'xml': 'http://www.w3.org/XML/1998/namespace'
};
10248
var XSI_TYPE = 'xsi:type';
10250
function serializeFormat(element) {
 return element.xml && element.xml.serialize;
}
10254
function serializeAsType(element) {
 return serializeFormat(element) === XSI_TYPE;
}
10258
function serializeAsProperty(element) {
 return serializeFormat(element) === 'property';
}
10262
function capitalize(str) {
 return str.charAt(0).toUpperCase() + str.slice(1);
}
10266
function aliasToName(aliasNs, pkg) {
10268
 if (!hasLowerCaseAlias(pkg)) {
   return aliasNs.name;
 }
10272
 return aliasNs.prefix + ':' + capitalize(aliasNs.localName);
}
10275
function prefixedToName(nameNs, pkg) {
10277
 var name = nameNs.name,
     localName = nameNs.localName;
10280
 var typePrefix = pkg.xml && pkg.xml.typePrefix;
10282
 if (typePrefix && localName.indexOf(typePrefix) === 0) {
   return nameNs.prefix + ':' + localName.slice(typePrefix.length);
 } else {
   return name;
 }
}
10289
function normalizeXsiTypeName(name, model) {
10291
 var nameNs = parseName(name);
 var pkg = model.getPackage(nameNs.prefix);
10294
 return prefixedToName(nameNs, pkg);
}
10297
function error$1(message) {
 return new Error(message);
}
10301
/**
* Get the moddle descriptor for a given instance or type.
*
* @param  {ModdleElement|Function} element
*
* @return {Object} the moddle descriptor
*/
function getModdleDescriptor(element) {
 return element.$descriptor;
}
10312
10313
/**
* A parse context.
*
* @class
*
* @param {Object} options
* @param {ElementHandler} options.rootHandler the root handler for parsing a document
* @param {boolean} [options.lax=false] whether or not to ignore invalid elements
*/
function Context(options) {
10324
 /**
  * @property {ElementHandler} rootHandler
  */
10328
 /**
  * @property {Boolean} lax
  */
10332
 assign(this, options);
10334
 this.elementsById = {};
 this.references = [];
 this.warnings = [];
10338
 /**
  * Add an unresolved reference.
  *
  * @param {Object} reference
  */
 this.addReference = function(reference) {
   this.references.push(reference);
 };
10347
 /**
  * Add a processed element.
  *
  * @param {ModdleElement} element
  */
 this.addElement = function(element) {
10354
   if (!element) {
     throw error$1('expected element');
   }
10358
   var elementsById = this.elementsById;
10360
   var descriptor = getModdleDescriptor(element);
10362
   var idProperty = descriptor.idProperty,
       id;
10365
   if (idProperty) {
     id = element.get(idProperty.name);
10368
     if (id) {
10370
       // for QName validation as per http://www.w3.org/TR/REC-xml/#NT-NameChar
       if (!/^([a-z][\w-.]*:)?[a-z_][\w-.]*$/i.test(id)) {
         throw new Error('illegal ID <' + id + '>');
       }
10375
       if (elementsById[id]) {
         throw error$1('duplicate ID <' + id + '>');
       }
10379
       elementsById[id] = element;
     }
   }
 };
10384
 /**
  * Add an import warning.
  *
  * @param {Object} warning
  * @param {String} warning.message
  * @param {Error} [warning.error]
  */
 this.addWarning = function(warning) {
   this.warnings.push(warning);
 };
}
10396
function BaseHandler() {}
10398
BaseHandler.prototype.handleEnd = function() {};
BaseHandler.prototype.handleText = function() {};
BaseHandler.prototype.handleNode = function() {};
10402
10403
/**
* A simple pass through handler that does nothing except for
* ignoring all input it receives.
*
* This is used to ignore unknown elements and
* attributes.
*/
function NoopHandler() { }
10412
NoopHandler.prototype = Object.create(BaseHandler.prototype);
10414
NoopHandler.prototype.handleNode = function() {
 return this;
};
10418
function BodyHandler() {}
10420
BodyHandler.prototype = Object.create(BaseHandler.prototype);
10422
BodyHandler.prototype.handleText = function(text) {
 this.body = (this.body || '') + text;
};
10426
function ReferenceHandler(property, context) {
 this.property = property;
 this.context = context;
}
10431
ReferenceHandler.prototype = Object.create(BodyHandler.prototype);
10433
ReferenceHandler.prototype.handleNode = function(node) {
10435
 if (this.element) {
   throw error$1('expected no sub nodes');
 } else {
   this.element = this.createReference(node);
 }
10441
 return this;
};
10444
ReferenceHandler.prototype.handleEnd = function() {
 this.element.id = this.body;
};
10448
ReferenceHandler.prototype.createReference = function(node) {
 return {
   property: this.property.ns.name,
   id: ''
 };
};
10455
function ValueHandler(propertyDesc, element) {
 this.element = element;
 this.propertyDesc = propertyDesc;
}
10460
ValueHandler.prototype = Object.create(BodyHandler.prototype);
10462
ValueHandler.prototype.handleEnd = function() {
10464
 var value = this.body || '',
     element = this.element,
     propertyDesc = this.propertyDesc;
10468
 value = coerceType(propertyDesc.type, value);
10470
 if (propertyDesc.isMany) {
   element.get(propertyDesc.name).push(value);
 } else {
   element.set(propertyDesc.name, value);
 }
};
10477
10478
function BaseElementHandler() {}
10480
BaseElementHandler.prototype = Object.create(BodyHandler.prototype);
10482
BaseElementHandler.prototype.handleNode = function(node) {
 var parser = this,
     element = this.element;
10486
 if (!element) {
   element = this.element = this.createElement(node);
10489
   this.context.addElement(element);
 } else {
   parser = this.handleChild(node);
 }
10494
 return parser;
};
10497
/**
* @class Reader.ElementHandler
*
*/
function ElementHandler(model, typeName, context) {
 this.model = model;
 this.type = model.getType(typeName);
 this.context = context;
}
10507
ElementHandler.prototype = Object.create(BaseElementHandler.prototype);
10509
ElementHandler.prototype.addReference = function(reference) {
 this.context.addReference(reference);
};
10513
ElementHandler.prototype.handleText = function(text) {
10515
 var element = this.element,
     descriptor = getModdleDescriptor(element),
     bodyProperty = descriptor.bodyProperty;
10519
 if (!bodyProperty) {
   throw error$1('unexpected body text <' + text + '>');
 }
10523
 BodyHandler.prototype.handleText.call(this, text);
};
10526
ElementHandler.prototype.handleEnd = function() {
10528
 var value = this.body,
     element = this.element,
     descriptor = getModdleDescriptor(element),
     bodyProperty = descriptor.bodyProperty;
10533
 if (bodyProperty && value !== undefined) {
   value = coerceType(bodyProperty.type, value);
   element.set(bodyProperty.name, value);
 }
};
10539
/**
* Create an instance of the model from the given node.
*
* @param  {Element} node the xml node
*/
ElementHandler.prototype.createElement = function(node) {
 var attributes = node.attributes,
     Type = this.type,
     descriptor = getModdleDescriptor(Type),
     context = this.context,
     instance = new Type({}),
     model = this.model,
     propNameNs;
10553
 forEach$2(attributes, function(value, name) {
10555
   var prop = descriptor.propertiesByName[name],
       values;
10558
   if (prop && prop.isReference) {
10560
     if (!prop.isMany) {
       context.addReference({
         element: instance,
         property: prop.ns.name,
         id: value
       });
     } else {
10568
       // IDREFS: parse references as whitespace-separated list
       values = value.split(' ');
10571
       forEach$2(values, function(v) {
         context.addReference({
           element: instance,
           property: prop.ns.name,
           id: v
         });
       });
     }
10580
   } else {
     if (prop) {
       value = coerceType(prop.type, value);
     } else
     if (name !== 'xmlns') {
       propNameNs = parseName(name, descriptor.ns.prefix);
10587
       // check whether attribute is defined in a well-known namespace
       // if that is the case we emit a warning to indicate potential misuse
       if (model.getPackage(propNameNs.prefix)) {
10591
         context.addWarning({
           message: 'unknown attribute <' + name + '>',
           element: instance,
           property: name,
           value: value
         });
       }
     }
10600
     instance.set(name, value);
   }
 });
10604
 return instance;
};
10607
ElementHandler.prototype.getPropertyForNode = function(node) {
10609
 var name = node.name;
 var nameNs = parseName(name);
10612
 var type = this.type,
     model = this.model,
     descriptor = getModdleDescriptor(type);
10616
 var propertyName = nameNs.name,
     property = descriptor.propertiesByName[propertyName],
     elementTypeName,
     elementType;
10621
 // search for properties by name first
10623
 if (property && !property.isAttr) {
10625
   if (serializeAsType(property)) {
     elementTypeName = node.attributes[XSI_TYPE];
10628
     // xsi type is optional, if it does not exists the
     // default type is assumed
     if (elementTypeName) {
10632
       // take possible type prefixes from XML
       // into account, i.e.: xsi:type="t{ActualType}"
       elementTypeName = normalizeXsiTypeName(elementTypeName, model);
10636
       elementType = model.getType(elementTypeName);
10638
       return assign({}, property, {
         effectiveType: getModdleDescriptor(elementType).name
       });
     }
   }
10644
   // search for properties by name first
   return property;
 }
10648
 var pkg = model.getPackage(nameNs.prefix);
10650
 if (pkg) {
   elementTypeName = aliasToName(nameNs, pkg);
   elementType = model.getType(elementTypeName);
10654
   // search for collection members later
   property = find(descriptor.properties, function(p) {
     return !p.isVirtual && !p.isReference && !p.isAttribute && elementType.hasType(p.type);
   });
10659
   if (property) {
     return assign({}, property, {
       effectiveType: getModdleDescriptor(elementType).name
     });
   }
 } else {
10666
   // parse unknown element (maybe extension)
   property = find(descriptor.properties, function(p) {
     return !p.isReference && !p.isAttribute && p.type === 'Element';
   });
10671
   if (property) {
     return property;
   }
 }
10676
 throw error$1('unrecognized element <' + nameNs.name + '>');
};
10679
ElementHandler.prototype.toString = function() {
 return 'ElementDescriptor[' + getModdleDescriptor(this.type).name + ']';
};
10683
ElementHandler.prototype.valueHandler = function(propertyDesc, element) {
 return new ValueHandler(propertyDesc, element);
};
10687
ElementHandler.prototype.referenceHandler = function(propertyDesc) {
 return new ReferenceHandler(propertyDesc, this.context);
};
10691
ElementHandler.prototype.handler = function(type) {
 if (type === 'Element') {
   return new GenericElementHandler(this.model, type, this.context);
 } else {
   return new ElementHandler(this.model, type, this.context);
 }
};
10699
/**
* Handle the child element parsing
*
* @param  {Element} node the xml node
*/
ElementHandler.prototype.handleChild = function(node) {
 var propertyDesc, type, element, childHandler;
10707
 propertyDesc = this.getPropertyForNode(node);
 element = this.element;
10710
 type = propertyDesc.effectiveType || propertyDesc.type;
10712
 if (isSimple(type)) {
   return this.valueHandler(propertyDesc, element);
 }
10716
 if (propertyDesc.isReference) {
   childHandler = this.referenceHandler(propertyDesc).handleNode(node);
 } else {
   childHandler = this.handler(type).handleNode(node);
 }
10722
 var newElement = childHandler.element;
10724
 // child handles may decide to skip elements
 // by not returning anything
 if (newElement !== undefined) {
10728
   if (propertyDesc.isMany) {
     element.get(propertyDesc.name).push(newElement);
   } else {
     element.set(propertyDesc.name, newElement);
   }
10734
   if (propertyDesc.isReference) {
     assign(newElement, {
       element: element
     });
10739
     this.context.addReference(newElement);
   } else {
10742
     // establish child -> parent relationship
     newElement.$parent = element;
   }
 }
10747
 return childHandler;
};
10750
/**
* An element handler that performs special validation
* to ensure the node it gets initialized with matches
* the handlers type (namespace wise).
*
* @param {Moddle} model
* @param {String} typeName
* @param {Context} context
*/
function RootElementHandler(model, typeName, context) {
 ElementHandler.call(this, model, typeName, context);
}
10763
RootElementHandler.prototype = Object.create(ElementHandler.prototype);
10765
RootElementHandler.prototype.createElement = function(node) {
10767
 var name = node.name,
     nameNs = parseName(name),
     model = this.model,
     type = this.type,
     pkg = model.getPackage(nameNs.prefix),
     typeName = pkg && aliasToName(nameNs, pkg) || name;
10774
 // verify the correct namespace if we parse
 // the first element in the handler tree
 //
 // this ensures we don't mistakenly import wrong namespace elements
 if (!type.hasType(typeName)) {
   throw error$1('unexpected element <' + node.originalName + '>');
 }
10782
 return ElementHandler.prototype.createElement.call(this, node);
};
10785
10786
function GenericElementHandler(model, typeName, context) {
 this.model = model;
 this.context = context;
}
10791
GenericElementHandler.prototype = Object.create(BaseElementHandler.prototype);
10793
GenericElementHandler.prototype.createElement = function(node) {
10795
 var name = node.name,
     ns = parseName(name),
     prefix = ns.prefix,
     uri = node.ns[prefix + '$uri'],
     attributes = node.attributes;
10801
 return this.model.createAny(name, uri, attributes);
};
10804
GenericElementHandler.prototype.handleChild = function(node) {
10806
 var handler = new GenericElementHandler(this.model, 'Element', this.context).handleNode(node),
     element = this.element;
10809
 var newElement = handler.element,
     children;
10812
 if (newElement !== undefined) {
   children = element.$children = element.$children || [];
   children.push(newElement);
10816
   // establish child -> parent relationship
   newElement.$parent = element;
 }
10820
 return handler;
};
10823
GenericElementHandler.prototype.handleEnd = function() {
 if (this.body) {
   this.element.$body = this.body;
 }
};
10829
/**
* A reader for a meta-model
*
* @param {Object} options
* @param {Model} options.model used to read xml files
* @param {Boolean} options.lax whether to make parse errors warnings
*/
function Reader(options) {
10838
 if (options instanceof Moddle) {
   options = {
     model: options
   };
 }
10844
 assign(this, { lax: false }, options);
}
10847
/**
* The fromXML result.
*
* @typedef {Object} ParseResult
*
* @property {ModdleElement} rootElement
* @property {Array<Object>} references
* @property {Array<Error>} warnings
* @property {Object} elementsById - a mapping containing each ID -> ModdleElement
*/
10858
/**
* The fromXML result.
*
* @typedef {Error} ParseError
*
* @property {Array<Error>} warnings
*/
10866
/**
* Parse the given XML into a moddle document tree.
*
* @param {String} xml
* @param {ElementHandler|Object} options or rootHandler
*
* @returns {Promise<ParseResult, ParseError>}
*/
Reader.prototype.fromXML = function(xml, options, done) {
10876
 var rootHandler = options.rootHandler;
10878
 if (options instanceof ElementHandler) {
10880
   // root handler passed via (xml, { rootHandler: ElementHandler }, ...)
   rootHandler = options;
   options = {};
 } else {
   if (typeof options === 'string') {
10886
     // rootHandler passed via (xml, 'someString', ...)
     rootHandler = this.handler(options);
     options = {};
   } else if (typeof rootHandler === 'string') {
10891
     // rootHandler passed via (xml, { rootHandler: 'someString' }, ...)
     rootHandler = this.handler(rootHandler);
   }
 }
10896
 var model = this.model,
     lax = this.lax;
10899
 var context = new Context(assign({}, options, { rootHandler: rootHandler })),
     parser = new Parser({ proxy: true }),
     stack = createStack();
10903
 rootHandler.context = context;
10905
 // push root handler
 stack.push(rootHandler);
10908
10909
 /**
  * Handle error.
  *
  * @param  {Error} err
  * @param  {Function} getContext
  * @param  {boolean} lax
  *
  * @return {boolean} true if handled
  */
 function handleError(err, getContext, lax) {
10920
   var ctx = getContext();
10922
   var line = ctx.line,
       column = ctx.column,
       data = ctx.data;
10926
   // we receive the full context data here,
   // for elements trim down the information
   // to the tag name, only
   if (data.charAt(0) === '<' && data.indexOf(' ') !== -1) {
     data = data.slice(0, data.indexOf(' ')) + '>';
   }
10933
   var message =
     'unparsable content ' + (data ? data + ' ' : '') + 'detected\n\t' +
       'line: ' + line + '\n\t' +
       'column: ' + column + '\n\t' +
       'nested error: ' + err.message;
10939
   if (lax) {
     context.addWarning({
       message: message,
       error: err
     });
10945
     return true;
   } else {
     throw error$1(message);
   }
 }
10951
 function handleWarning(err, getContext) {
10953
   // just like handling errors in <lax=true> mode
   return handleError(err, getContext, true);
 }
10957
 /**
  * Resolve collected references on parse end.
  */
 function resolveReferences() {
10962
   var elementsById = context.elementsById;
   var references = context.references;
10965
   var i, r;
10967
   for (i = 0; (r = references[i]); i++) {
     var element = r.element;
     var reference = elementsById[r.id];
     var property = getModdleDescriptor(element).propertiesByName[r.property];
10972
     if (!reference) {
       context.addWarning({
         message: 'unresolved reference <' + r.id + '>',
         element: r.element,
         property: r.property,
         value: r.id
       });
     }
10981
     if (property.isMany) {
       var collection = element.get(property.name),
           idx = collection.indexOf(r);
10985
       // we replace an existing place holder (idx != -1) or
       // append to the collection instead
       if (idx === -1) {
         idx = collection.length;
       }
10991
       if (!reference) {
10993
         // remove unresolvable reference
         collection.splice(idx, 1);
       } else {
10997
         // add or update reference in collection
         collection[idx] = reference;
       }
     } else {
       element.set(property.name, reference);
     }
   }
 }
11006
 function handleClose() {
   stack.pop().handleEnd();
 }
11010
 var PREAMBLE_START_PATTERN = /^<\?xml /i;
11012
 var ENCODING_PATTERN = / encoding="([^"]+)"/i;
11014
 var UTF_8_PATTERN = /^utf-8$/i;
11016
 function handleQuestion(question) {
11018
   if (!PREAMBLE_START_PATTERN.test(question)) {
     return;
   }
11022
   var match = ENCODING_PATTERN.exec(question);
   var encoding = match && match[1];
11025
   if (!encoding || UTF_8_PATTERN.test(encoding)) {
     return;
   }
11029
   context.addWarning({
     message:
       'unsupported document encoding <' + encoding + '>, ' +
       'falling back to UTF-8'
   });
 }
11036
 function handleOpen(node, getContext) {
   var handler = stack.peek();
11039
   try {
     stack.push(handler.handleNode(node));
   } catch (err) {
11043
     if (handleError(err, getContext, lax)) {
       stack.push(new NoopHandler());
     }
   }
 }
11049
 function handleCData(text, getContext) {
11051
   try {
     stack.peek().handleText(text);
   } catch (err) {
     handleWarning(err, getContext);
   }
 }
11058
 function handleText(text, getContext) {
11060
   // strip whitespace only nodes, i.e. before
   // <!CDATA[ ... ]> sections and in between tags
11063
   if (!text.trim()) {
     return;
   }
11067
   handleCData(text, getContext);
 }
11070
 var uriMap = model.getPackages().reduce(function(uriMap, p) {
   uriMap[p.uri] = p.prefix;
11073
   return uriMap;
 }, {
   'http://www.w3.org/XML/1998/namespace': 'xml' // add default xml ns
 });
 parser
   .ns(uriMap)
   .on('openTag', function(obj, decodeStr, selfClosing, getContext) {
11081
     // gracefully handle unparsable attributes (attrs=false)
     var attrs = obj.attrs || {};
11084
     var decodedAttrs = Object.keys(attrs).reduce(function(d, key) {
       var value = decodeStr(attrs[key]);
11087
       d[key] = value;
11089
       return d;
     }, {});
11092
     var node = {
       name: obj.name,
       originalName: obj.originalName,
       attributes: decodedAttrs,
       ns: obj.ns
     };
11099
     handleOpen(node, getContext);
   })
   .on('question', handleQuestion)
   .on('closeTag', handleClose)
   .on('cdata', handleCData)
   .on('text', function(text, decodeEntities, getContext) {
     handleText(decodeEntities(text), getContext);
   })
   .on('error', handleError)
   .on('warn', handleWarning);
11110
 // async XML parsing to make sure the execution environment
 // (node or brower) is kept responsive and that certain optimization
 // strategies can kick in.
 return new Promise(function(resolve, reject) {
11115
   var err;
11117
   try {
     parser.parse(xml);
11120
     resolveReferences();
   } catch (e) {
     err = e;
   }
11125
   var rootElement = rootHandler.element;
11127
   if (!err && !rootElement) {
     err = error$1('failed to parse document as <' + rootHandler.type.$descriptor.name + '>');
   }
11131
   var warnings = context.warnings;
   var references = context.references;
   var elementsById = context.elementsById;
11135
   if (err) {
     err.warnings = warnings;
11138
     return reject(err);
   } else {
     return resolve({
       rootElement: rootElement,
       elementsById: elementsById,
       references: references,
       warnings: warnings
     });
   }
 });
};
11150
Reader.prototype.handler = function(name) {
 return new RootElementHandler(this.model, name);
};
11154
11155
// helpers //////////////////////////
11157
function createStack() {
 var stack = [];
11160
 Object.defineProperty(stack, 'peek', {
   value: function() {
     return this[this.length - 1];
   }
 });
11166
 return stack;
}
11169
var XML_PREAMBLE = '<?xml version="1.0" encoding="UTF-8"?>\n';
11171
var ESCAPE_ATTR_CHARS = /<|>|'|"|&|\n\r|\n/g;
var ESCAPE_CHARS = /<|>|&/g;
11174
11175
function Namespaces(parent) {
11177
 var prefixMap = {};
 var uriMap = {};
 var used = {};
11181
 var wellknown = [];
 var custom = [];
11184
 // API
11186
 this.byUri = function(uri) {
   return uriMap[uri] || (
     parent && parent.byUri(uri)
   );
 };
11192
 this.add = function(ns, isWellknown) {
11194
   uriMap[ns.uri] = ns;
11196
   if (isWellknown) {
     wellknown.push(ns);
   } else {
     custom.push(ns);
   }
11202
   this.mapPrefix(ns.prefix, ns.uri);
 };
11205
 this.uriByPrefix = function(prefix) {
   return prefixMap[prefix || 'xmlns'];
 };
11209
 this.mapPrefix = function(prefix, uri) {
   prefixMap[prefix || 'xmlns'] = uri;
 };
11213
 this.getNSKey = function(ns) {
   return (ns.prefix !== undefined) ? (ns.uri + '|' + ns.prefix) : ns.uri;
 };
11217
 this.logUsed = function(ns) {
11219
   var uri = ns.uri;
   var nsKey = this.getNSKey(ns);
11222
   used[nsKey] = this.byUri(uri);
11224
   // Inform parent recursively about the usage of this NS
   if (parent) {
     parent.logUsed(ns);
   }
 };
11230
 this.getUsed = function(ns) {
11232
   function isUsed(ns) {
     var nsKey = self.getNSKey(ns);
11235
     return used[nsKey];
   }
11238
   var self = this;
11240
   var allNs = [].concat(wellknown, custom);
11242
   return allNs.filter(isUsed);
 };
11245
}
11247
function lower(string) {
 return string.charAt(0).toLowerCase() + string.slice(1);
}
11251
function nameToAlias(name, pkg) {
 if (hasLowerCaseAlias(pkg)) {
   return lower(name);
 } else {
   return name;
 }
}
11259
function inherits(ctor, superCtor) {
 ctor.super_ = superCtor;
 ctor.prototype = Object.create(superCtor.prototype, {
   constructor: {
     value: ctor,
     enumerable: false,
     writable: true,
     configurable: true
   }
 });
}
11271
function nsName(ns) {
 if (isString(ns)) {
   return ns;
 } else {
   return (ns.prefix ? ns.prefix + ':' : '') + ns.localName;
 }
}
11279
function getNsAttrs(namespaces) {
11281
 return namespaces.getUsed().filter(function(ns) {
11283
   // do not serialize built in <xml> namespace
   return ns.prefix !== 'xml';
 }).map(function(ns) {
   var name = 'xmlns' + (ns.prefix ? ':' + ns.prefix : '');
   return { name: name, value: ns.uri };
 });
11290
}
11292
function getElementNs(ns, descriptor) {
 if (descriptor.isGeneric) {
   return assign({ localName: descriptor.ns.localName }, ns);
 } else {
   return assign({ localName: nameToAlias(descriptor.ns.localName, descriptor.$pkg) }, ns);
 }
}
11300
function getPropertyNs(ns, descriptor) {
 return assign({ localName: descriptor.ns.localName }, ns);
}
11304
function getSerializableProperties(element) {
 var descriptor = element.$descriptor;
11307
 return filter(descriptor.properties, function(p) {
   var name = p.name;
11310
   if (p.isVirtual) {
     return false;
   }
11314
   // do not serialize defaults
   if (!has$2(element, name)) {
     return false;
   }
11319
   var value = element[name];
11321
   // do not serialize default equals
   if (value === p.default) {
     return false;
   }
11326
   // do not serialize null properties
   if (value === null) {
     return false;
   }
11331
   return p.isMany ? value.length : true;
 });
}
11335
var ESCAPE_ATTR_MAP = {
 '\n': '#10',
 '\n\r': '#10',
 '"': '#34',
 '\'': '#39',
 '<': '#60',
 '>': '#62',
 '&': '#38'
};
11345
var ESCAPE_MAP = {
 '<': 'lt',
 '>': 'gt',
 '&': 'amp'
};
11351
function escape(str, charPattern, replaceMap) {
11353
 // ensure we are handling strings here
 str = isString(str) ? str : '' + str;
11356
 return str.replace(charPattern, function(s) {
   return '&' + replaceMap[s] + ';';
 });
}
11361
/**
* Escape a string attribute to not contain any bad values (line breaks, '"', ...)
*
* @param {String} str the string to escape
* @return {String} the escaped string
*/
function escapeAttr(str) {
 return escape(str, ESCAPE_ATTR_CHARS, ESCAPE_ATTR_MAP);
}
11371
function escapeBody(str) {
 return escape(str, ESCAPE_CHARS, ESCAPE_MAP);
}
11375
function filterAttributes(props) {
 return filter(props, function(p) { return p.isAttr; });
}
11379
function filterContained(props) {
 return filter(props, function(p) { return !p.isAttr; });
}
11383
11384
function ReferenceSerializer(tagName) {
 this.tagName = tagName;
}
11388
ReferenceSerializer.prototype.build = function(element) {
 this.element = element;
 return this;
};
11393
ReferenceSerializer.prototype.serializeTo = function(writer) {
 writer
   .appendIndent()
   .append('<' + this.tagName + '>' + this.element.id + '</' + this.tagName + '>')
   .appendNewLine();
};
11400
function BodySerializer() {}
11402
BodySerializer.prototype.serializeValue =
BodySerializer.prototype.serializeTo = function(writer) {
 writer.append(
   this.escape
     ? escapeBody(this.value)
     : this.value
 );
};
11411
BodySerializer.prototype.build = function(prop, value) {
 this.value = value;
11414
 if (prop.type === 'String' && value.search(ESCAPE_CHARS) !== -1) {
   this.escape = true;
 }
11418
 return this;
};
11421
function ValueSerializer(tagName) {
 this.tagName = tagName;
}
11425
inherits(ValueSerializer, BodySerializer);
11427
ValueSerializer.prototype.serializeTo = function(writer) {
11429
 writer
   .appendIndent()
   .append('<' + this.tagName + '>');
11433
 this.serializeValue(writer);
11435
 writer
   .append('</' + this.tagName + '>')
   .appendNewLine();
};
11440
function ElementSerializer(parent, propertyDescriptor) {
 this.body = [];
 this.attrs = [];
11444
 this.parent = parent;
 this.propertyDescriptor = propertyDescriptor;
}
11448
ElementSerializer.prototype.build = function(element) {
 this.element = element;
11451
 var elementDescriptor = element.$descriptor,
     propertyDescriptor = this.propertyDescriptor;
11454
 var otherAttrs,
     properties;
11457
 var isGeneric = elementDescriptor.isGeneric;
11459
 if (isGeneric) {
   otherAttrs = this.parseGeneric(element);
 } else {
   otherAttrs = this.parseNsAttributes(element);
 }
11465
 if (propertyDescriptor) {
   this.ns = this.nsPropertyTagName(propertyDescriptor);
 } else {
   this.ns = this.nsTagName(elementDescriptor);
 }
11471
 // compute tag name
 this.tagName = this.addTagName(this.ns);
11474
 if (!isGeneric) {
   properties = getSerializableProperties(element);
11477
   this.parseAttributes(filterAttributes(properties));
   this.parseContainments(filterContained(properties));
 }
11481
 this.parseGenericAttributes(element, otherAttrs);
11483
 return this;
};
11486
ElementSerializer.prototype.nsTagName = function(descriptor) {
 var effectiveNs = this.logNamespaceUsed(descriptor.ns);
 return getElementNs(effectiveNs, descriptor);
};
11491
ElementSerializer.prototype.nsPropertyTagName = function(descriptor) {
 var effectiveNs = this.logNamespaceUsed(descriptor.ns);
 return getPropertyNs(effectiveNs, descriptor);
};
11496
ElementSerializer.prototype.isLocalNs = function(ns) {
 return ns.uri === this.ns.uri;
};
11500
/**
* Get the actual ns attribute name for the given element.
*
* @param {Object} element
* @param {Boolean} [element.inherited=false]
*
* @return {Object} nsName
*/
ElementSerializer.prototype.nsAttributeName = function(element) {
11510
 var ns;
11512
 if (isString(element)) {
   ns = parseName(element);
 } else {
   ns = element.ns;
 }
11518
 // return just local name for inherited attributes
 if (element.inherited) {
   return { localName: ns.localName };
 }
11523
 // parse + log effective ns
 var effectiveNs = this.logNamespaceUsed(ns);
11526
 // LOG ACTUAL namespace use
 this.getNamespaces().logUsed(effectiveNs);
11529
 // strip prefix if same namespace like parent
 if (this.isLocalNs(effectiveNs)) {
   return { localName: ns.localName };
 } else {
   return assign({ localName: ns.localName }, effectiveNs);
 }
};
11537
ElementSerializer.prototype.parseGeneric = function(element) {
11539
 var self = this,
     body = this.body;
11542
 var attributes = [];
11544
 forEach$2(element, function(val, key) {
11546
   var nonNsAttr;
11548
   if (key === '$body') {
     body.push(new BodySerializer().build({ type: 'String' }, val));
   } else
   if (key === '$children') {
     forEach$2(val, function(child) {
       body.push(new ElementSerializer(self).build(child));
     });
   } else
   if (key.indexOf('$') !== 0) {
     nonNsAttr = self.parseNsAttribute(element, key, val);
11559
     if (nonNsAttr) {
       attributes.push({ name: key, value: val });
     }
   }
 });
11565
 return attributes;
};
11568
ElementSerializer.prototype.parseNsAttribute = function(element, name, value) {
 var model = element.$model;
11571
 var nameNs = parseName(name);
11573
 var ns;
11575
 // parse xmlns:foo="http://foo.bar"
 if (nameNs.prefix === 'xmlns') {
   ns = { prefix: nameNs.localName, uri: value };
 }
11580
 // parse xmlns="http://foo.bar"
 if (!nameNs.prefix && nameNs.localName === 'xmlns') {
   ns = { uri: value };
 }
11585
 if (!ns) {
   return {
     name: name,
     value: value
   };
 }
11592
 if (model && model.getPackage(value)) {
11594
   // register well known namespace
   this.logNamespace(ns, true, true);
 } else {
11598
   // log custom namespace directly as used
   var actualNs = this.logNamespaceUsed(ns, true);
11601
   this.getNamespaces().logUsed(actualNs);
 }
};
11605
11606
/**
* Parse namespaces and return a list of left over generic attributes
*
* @param  {Object} element
* @return {Array<Object>}
*/
ElementSerializer.prototype.parseNsAttributes = function(element, attrs) {
 var self = this;
11615
 var genericAttrs = element.$attrs;
11617
 var attributes = [];
11619
 // parse namespace attributes first
 // and log them. push non namespace attributes to a list
 // and process them later
 forEach$2(genericAttrs, function(value, name) {
11624
   var nonNsAttr = self.parseNsAttribute(element, name, value);
11626
   if (nonNsAttr) {
     attributes.push(nonNsAttr);
   }
 });
11631
 return attributes;
};
11634
ElementSerializer.prototype.parseGenericAttributes = function(element, attributes) {
11636
 var self = this;
11638
 forEach$2(attributes, function(attr) {
11640
   // do not serialize xsi:type attribute
   // it is set manually based on the actual implementation type
   if (attr.name === XSI_TYPE) {
     return;
   }
11646
   try {
     self.addAttribute(self.nsAttributeName(attr.name), attr.value);
   } catch (e) {
     console.warn(
       'missing namespace information for ',
       attr.name, '=', attr.value, 'on', element,
       e);
   }
 });
};
11657
ElementSerializer.prototype.parseContainments = function(properties) {
11659
 var self = this,
     body = this.body,
     element = this.element;
11663
 forEach$2(properties, function(p) {
   var value = element.get(p.name),
       isReference = p.isReference,
       isMany = p.isMany;
11668
   if (!isMany) {
     value = [ value ];
   }
11672
   if (p.isBody) {
     body.push(new BodySerializer().build(p, value[0]));
   } else
   if (isSimple(p.type)) {
     forEach$2(value, function(v) {
       body.push(new ValueSerializer(self.addTagName(self.nsPropertyTagName(p))).build(p, v));
     });
   } else
   if (isReference) {
     forEach$2(value, function(v) {
       body.push(new ReferenceSerializer(self.addTagName(self.nsPropertyTagName(p))).build(v));
     });
   } else {
11686
     // allow serialization via type
     // rather than element name
     var asType = serializeAsType(p),
         asProperty = serializeAsProperty(p);
11691
     forEach$2(value, function(v) {
       var serializer;
11694
       if (asType) {
         serializer = new TypeSerializer(self, p);
       } else
       if (asProperty) {
         serializer = new ElementSerializer(self, p);
       } else {
         serializer = new ElementSerializer(self);
       }
11703
       body.push(serializer.build(v));
     });
   }
 });
};
11709
ElementSerializer.prototype.getNamespaces = function(local) {
11711
 var namespaces = this.namespaces,
     parent = this.parent,
     parentNamespaces;
11715
 if (!namespaces) {
   parentNamespaces = parent && parent.getNamespaces();
11718
   if (local || !parentNamespaces) {
     this.namespaces = namespaces = new Namespaces(parentNamespaces);
   } else {
     namespaces = parentNamespaces;
   }
 }
11725
 return namespaces;
};
11728
ElementSerializer.prototype.logNamespace = function(ns, wellknown, local) {
 var namespaces = this.getNamespaces(local);
11731
 var nsUri = ns.uri,
     nsPrefix = ns.prefix;
11734
 var existing = namespaces.byUri(nsUri);
11736
 if (!existing || local) {
   namespaces.add(ns, wellknown);
 }
11740
 namespaces.mapPrefix(nsPrefix, nsUri);
11742
 return ns;
};
11745
ElementSerializer.prototype.logNamespaceUsed = function(ns, local) {
 var element = this.element,
     model = element.$model,
     namespaces = this.getNamespaces(local);
11750
 // ns may be
 //
 //   * prefix only
 //   * prefix:uri
 //   * localName only
11756
 var prefix = ns.prefix,
     uri = ns.uri,
     newPrefix, idx,
     wellknownUri;
11761
 // handle anonymous namespaces (elementForm=unqualified), cf. #23
 if (!prefix && !uri) {
   return { localName: ns.localName };
 }
11766
 wellknownUri = DEFAULT_NS_MAP[prefix] || model && (model.getPackage(prefix) || {}).uri;
11768
 uri = uri || wellknownUri || namespaces.uriByPrefix(prefix);
11770
 if (!uri) {
   throw new Error('no namespace uri given for prefix <' + prefix + '>');
 }
11774
 ns = namespaces.byUri(uri);
11776
 if (!ns) {
   newPrefix = prefix;
   idx = 1;
11780
   // find a prefix that is not mapped yet
   while (namespaces.uriByPrefix(newPrefix)) {
     newPrefix = prefix + '_' + idx++;
   }
11785
   ns = this.logNamespace({ prefix: newPrefix, uri: uri }, wellknownUri === uri);
 }
11788
 if (prefix) {
   namespaces.mapPrefix(prefix, uri);
 }
11792
 return ns;
};
11795
ElementSerializer.prototype.parseAttributes = function(properties) {
 var self = this,
     element = this.element;
11799
 forEach$2(properties, function(p) {
11801
   var value = element.get(p.name);
11803
   if (p.isReference) {
11805
     if (!p.isMany) {
       value = value.id;
     }
     else {
       var values = [];
       forEach$2(value, function(v) {
         values.push(v.id);
       });
11814
       // IDREFS is a whitespace-separated list of references.
       value = values.join(' ');
     }
11818
   }
11820
   self.addAttribute(self.nsAttributeName(p), value);
 });
};
11824
ElementSerializer.prototype.addTagName = function(nsTagName) {
 var actualNs = this.logNamespaceUsed(nsTagName);
11827
 this.getNamespaces().logUsed(actualNs);
11829
 return nsName(nsTagName);
};
11832
ElementSerializer.prototype.addAttribute = function(name, value) {
 var attrs = this.attrs;
11835
 if (isString(value)) {
   value = escapeAttr(value);
 }
11839
 attrs.push({ name: name, value: value });
};
11842
ElementSerializer.prototype.serializeAttributes = function(writer) {
 var attrs = this.attrs,
     namespaces = this.namespaces;
11846
 if (namespaces) {
   attrs = getNsAttrs(namespaces).concat(attrs);
 }
11850
 forEach$2(attrs, function(a) {
   writer
     .append(' ')
     .append(nsName(a.name)).append('="').append(a.value).append('"');
 });
};
11857
ElementSerializer.prototype.serializeTo = function(writer) {
 var firstBody = this.body[0],
     indent = firstBody && firstBody.constructor !== BodySerializer;
11861
 writer
   .appendIndent()
   .append('<' + this.tagName);
11865
 this.serializeAttributes(writer);
11867
 writer.append(firstBody ? '>' : ' />');
11869
 if (firstBody) {
11871
   if (indent) {
     writer
       .appendNewLine()
       .indent();
   }
11877
   forEach$2(this.body, function(b) {
     b.serializeTo(writer);
   });
11881
   if (indent) {
     writer
       .unindent()
       .appendIndent();
   }
11887
   writer.append('</' + this.tagName + '>');
 }
11890
 writer.appendNewLine();
};
11893
/**
* A serializer for types that handles serialization of data types
*/
function TypeSerializer(parent, propertyDescriptor) {
 ElementSerializer.call(this, parent, propertyDescriptor);
}
11900
inherits(TypeSerializer, ElementSerializer);
11902
TypeSerializer.prototype.parseNsAttributes = function(element) {
11904
 // extracted attributes
 var attributes = ElementSerializer.prototype.parseNsAttributes.call(this, element);
11907
 var descriptor = element.$descriptor;
11909
 // only serialize xsi:type if necessary
 if (descriptor.name === this.propertyDescriptor.type) {
   return attributes;
 }
11914
 var typeNs = this.typeNs = this.nsTagName(descriptor);
 this.getNamespaces().logUsed(this.typeNs);
11917
 // add xsi:type attribute to represent the elements
 // actual type
11920
 var pkg = element.$model.getPackage(typeNs.uri),
     typePrefix = (pkg.xml && pkg.xml.typePrefix) || '';
11923
 this.addAttribute(
   this.nsAttributeName(XSI_TYPE),
   (typeNs.prefix ? typeNs.prefix + ':' : '') + typePrefix + descriptor.ns.localName
 );
11928
 return attributes;
};
11931
TypeSerializer.prototype.isLocalNs = function(ns) {
 return ns.uri === (this.typeNs || this.ns).uri;
};
11935
function SavingWriter() {
 this.value = '';
11938
 this.write = function(str) {
   this.value += str;
 };
}
11943
function FormatingWriter(out, format) {
11945
 var indent = [''];
11947
 this.append = function(str) {
   out.write(str);
11950
   return this;
 };
11953
 this.appendNewLine = function() {
   if (format) {
     out.write('\n');
   }
11958
   return this;
 };
11961
 this.appendIndent = function() {
   if (format) {
     out.write(indent.join('  '));
   }
11966
   return this;
 };
11969
 this.indent = function() {
   indent.push('');
   return this;
 };
11974
 this.unindent = function() {
   indent.pop();
   return this;
 };
}
11980
/**
* A writer for meta-model backed document trees
*
* @param {Object} options output options to pass into the writer
*/
function Writer(options) {
11987
 options = assign({ format: false, preamble: true }, options || {});
11989
 function toXML(tree, writer) {
   var internalWriter = writer || new SavingWriter();
   var formatingWriter = new FormatingWriter(internalWriter, options.format);
11993
   if (options.preamble) {
     formatingWriter.append(XML_PREAMBLE);
   }
11997
   new ElementSerializer().build(tree).serializeTo(formatingWriter);
11999
   if (!writer) {
     return internalWriter.value;
   }
 }
12004
 return {
   toXML: toXML
 };
}
12009
/**
* A sub class of {@link Moddle} with support for import and export of BPMN 2.0 xml files.
*
* @class BpmnModdle
* @extends Moddle
*
* @param {Object|Array} packages to use for instantiating the model
* @param {Object} [options] additional options to pass over
*/
function BpmnModdle(packages, options) {
 Moddle.call(this, packages, options);
}
12022
BpmnModdle.prototype = Object.create(Moddle.prototype);
12024
/**
* The fromXML result.
*
* @typedef {Object} ParseResult
*
* @property {ModdleElement} rootElement
* @property {Array<Object>} references
* @property {Array<Error>} warnings
* @property {Object} elementsById - a mapping containing each ID -> ModdleElement
*/
12035
/**
* The fromXML error.
*
* @typedef {Error} ParseError
*
* @property {Array<Error>} warnings
*/
12043
/**
* Instantiates a BPMN model tree from a given xml string.
*
* @param {String}   xmlStr
* @param {String}   [typeName='bpmn:Definitions'] name of the root element
* @param {Object}   [options]  options to pass to the underlying reader
*
* @returns {Promise<ParseResult, ParseError>}
*/
BpmnModdle.prototype.fromXML = function(xmlStr, typeName, options) {
12054
 if (!isString(typeName)) {
   options = typeName;
   typeName = 'bpmn:Definitions';
 }
12059
 var reader = new Reader(assign({ model: this, lax: true }, options));
 var rootHandler = reader.handler(typeName);
12062
 return reader.fromXML(xmlStr, rootHandler);
};
12065
12066
/**
* The toXML result.
*
* @typedef {Object} SerializationResult
*
* @property {String} xml
*/
12074
/**
* Serializes a BPMN 2.0 object tree to XML.
*
* @param {String}   element    the root element, typically an instance of `bpmn:Definitions`
* @param {Object}   [options]  to pass to the underlying writer
*
* @returns {Promise<SerializationResult, Error>}
*/
BpmnModdle.prototype.toXML = function(element, options) {
12084
 var writer = new Writer(options);
12086
 return new Promise(function(resolve, reject) {
   try {
     var result = writer.toXML(element);
12090
     return resolve({
       xml: result
     });
   } catch (err) {
     return reject(err);
   }
 });
};
12099
var name = "BPMN20";
var uri = "http://www.omg.org/spec/BPMN/20100524/MODEL";
var prefix = "bpmn";
var associations = [
];
var types = [
{
	name: "Interface",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "operations",
			type: "Operation",
			isMany: true
		},
		{
			name: "implementationRef",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Operation",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "inMessageRef",
			type: "Message",
			isReference: true
		},
		{
			name: "outMessageRef",
			type: "Message",
			isReference: true
		},
		{
			name: "errorRef",
			type: "Error",
			isMany: true,
			isReference: true
		},
		{
			name: "implementationRef",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "EndPoint",
	superClass: [
		"RootElement"
	]
},
{
	name: "Auditing",
	superClass: [
		"BaseElement"
	]
},
{
	name: "GlobalTask",
	superClass: [
		"CallableElement"
	],
	properties: [
		{
			name: "resources",
			type: "ResourceRole",
			isMany: true
		}
	]
},
{
	name: "Monitoring",
	superClass: [
		"BaseElement"
	]
},
{
	name: "Performer",
	superClass: [
		"ResourceRole"
	]
},
{
	name: "Process",
	superClass: [
		"FlowElementsContainer",
		"CallableElement"
	],
	properties: [
		{
			name: "processType",
			type: "ProcessType",
			isAttr: true
		},
		{
			name: "isClosed",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "auditing",
			type: "Auditing"
		},
		{
			name: "monitoring",
			type: "Monitoring"
		},
		{
			name: "properties",
			type: "Property",
			isMany: true
		},
		{
			name: "laneSets",
			isMany: true,
			replaces: "FlowElementsContainer#laneSets",
			type: "LaneSet"
		},
		{
			name: "flowElements",
			isMany: true,
			replaces: "FlowElementsContainer#flowElements",
			type: "FlowElement"
		},
		{
			name: "artifacts",
			type: "Artifact",
			isMany: true
		},
		{
			name: "resources",
			type: "ResourceRole",
			isMany: true
		},
		{
			name: "correlationSubscriptions",
			type: "CorrelationSubscription",
			isMany: true
		},
		{
			name: "supports",
			type: "Process",
			isMany: true,
			isReference: true
		},
		{
			name: "definitionalCollaborationRef",
			type: "Collaboration",
			isAttr: true,
			isReference: true
		},
		{
			name: "isExecutable",
			isAttr: true,
			type: "Boolean"
		}
	]
},
{
	name: "LaneSet",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "lanes",
			type: "Lane",
			isMany: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Lane",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "partitionElementRef",
			type: "BaseElement",
			isAttr: true,
			isReference: true
		},
		{
			name: "partitionElement",
			type: "BaseElement"
		},
		{
			name: "flowNodeRef",
			type: "FlowNode",
			isMany: true,
			isReference: true
		},
		{
			name: "childLaneSet",
			type: "LaneSet",
			xml: {
				serialize: "xsi:type"
			}
		}
	]
},
{
	name: "GlobalManualTask",
	superClass: [
		"GlobalTask"
	]
},
{
	name: "ManualTask",
	superClass: [
		"Task"
	]
},
{
	name: "UserTask",
	superClass: [
		"Task"
	],
	properties: [
		{
			name: "renderings",
			type: "Rendering",
			isMany: true
		},
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Rendering",
	superClass: [
		"BaseElement"
	]
},
{
	name: "HumanPerformer",
	superClass: [
		"Performer"
	]
},
{
	name: "PotentialOwner",
	superClass: [
		"HumanPerformer"
	]
},
{
	name: "GlobalUserTask",
	superClass: [
		"GlobalTask"
	],
	properties: [
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		},
		{
			name: "renderings",
			type: "Rendering",
			isMany: true
		}
	]
},
{
	name: "Gateway",
	isAbstract: true,
	superClass: [
		"FlowNode"
	],
	properties: [
		{
			name: "gatewayDirection",
			type: "GatewayDirection",
			"default": "Unspecified",
			isAttr: true
		}
	]
},
{
	name: "EventBasedGateway",
	superClass: [
		"Gateway"
	],
	properties: [
		{
			name: "instantiate",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "eventGatewayType",
			type: "EventBasedGatewayType",
			isAttr: true,
			"default": "Exclusive"
		}
	]
},
{
	name: "ComplexGateway",
	superClass: [
		"Gateway"
	],
	properties: [
		{
			name: "activationCondition",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "default",
			type: "SequenceFlow",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ExclusiveGateway",
	superClass: [
		"Gateway"
	],
	properties: [
		{
			name: "default",
			type: "SequenceFlow",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "InclusiveGateway",
	superClass: [
		"Gateway"
	],
	properties: [
		{
			name: "default",
			type: "SequenceFlow",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ParallelGateway",
	superClass: [
		"Gateway"
	]
},
{
	name: "RootElement",
	isAbstract: true,
	superClass: [
		"BaseElement"
	]
},
{
	name: "Relationship",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "type",
			isAttr: true,
			type: "String"
		},
		{
			name: "direction",
			type: "RelationshipDirection",
			isAttr: true
		},
		{
			name: "source",
			isMany: true,
			isReference: true,
			type: "Element"
		},
		{
			name: "target",
			isMany: true,
			isReference: true,
			type: "Element"
		}
	]
},
{
	name: "BaseElement",
	isAbstract: true,
	properties: [
		{
			name: "id",
			isAttr: true,
			type: "String",
			isId: true
		},
		{
			name: "documentation",
			type: "Documentation",
			isMany: true
		},
		{
			name: "extensionDefinitions",
			type: "ExtensionDefinition",
			isMany: true,
			isReference: true
		},
		{
			name: "extensionElements",
			type: "ExtensionElements"
		}
	]
},
{
	name: "Extension",
	properties: [
		{
			name: "mustUnderstand",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "definition",
			type: "ExtensionDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ExtensionDefinition",
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "extensionAttributeDefinitions",
			type: "ExtensionAttributeDefinition",
			isMany: true
		}
	]
},
{
	name: "ExtensionAttributeDefinition",
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "type",
			isAttr: true,
			type: "String"
		},
		{
			name: "isReference",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "extensionDefinition",
			type: "ExtensionDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ExtensionElements",
	properties: [
		{
			name: "valueRef",
			isAttr: true,
			isReference: true,
			type: "Element"
		},
		{
			name: "values",
			type: "Element",
			isMany: true
		},
		{
			name: "extensionAttributeDefinition",
			type: "ExtensionAttributeDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Documentation",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "text",
			type: "String",
			isBody: true
		},
		{
			name: "textFormat",
			"default": "text/plain",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Event",
	isAbstract: true,
	superClass: [
		"FlowNode",
		"InteractionNode"
	],
	properties: [
		{
			name: "properties",
			type: "Property",
			isMany: true
		}
	]
},
{
	name: "IntermediateCatchEvent",
	superClass: [
		"CatchEvent"
	]
},
{
	name: "IntermediateThrowEvent",
	superClass: [
		"ThrowEvent"
	]
},
{
	name: "EndEvent",
	superClass: [
		"ThrowEvent"
	]
},
{
	name: "StartEvent",
	superClass: [
		"CatchEvent"
	],
	properties: [
		{
			name: "isInterrupting",
			"default": true,
			isAttr: true,
			type: "Boolean"
		}
	]
},
{
	name: "ThrowEvent",
	isAbstract: true,
	superClass: [
		"Event"
	],
	properties: [
		{
			name: "dataInputs",
			type: "DataInput",
			isMany: true
		},
		{
			name: "dataInputAssociations",
			type: "DataInputAssociation",
			isMany: true
		},
		{
			name: "inputSet",
			type: "InputSet"
		},
		{
			name: "eventDefinitions",
			type: "EventDefinition",
			isMany: true
		},
		{
			name: "eventDefinitionRef",
			type: "EventDefinition",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "CatchEvent",
	isAbstract: true,
	superClass: [
		"Event"
	],
	properties: [
		{
			name: "parallelMultiple",
			isAttr: true,
			type: "Boolean",
			"default": false
		},
		{
			name: "dataOutputs",
			type: "DataOutput",
			isMany: true
		},
		{
			name: "dataOutputAssociations",
			type: "DataOutputAssociation",
			isMany: true
		},
		{
			name: "outputSet",
			type: "OutputSet"
		},
		{
			name: "eventDefinitions",
			type: "EventDefinition",
			isMany: true
		},
		{
			name: "eventDefinitionRef",
			type: "EventDefinition",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "BoundaryEvent",
	superClass: [
		"CatchEvent"
	],
	properties: [
		{
			name: "cancelActivity",
			"default": true,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "attachedToRef",
			type: "Activity",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "EventDefinition",
	isAbstract: true,
	superClass: [
		"RootElement"
	]
},
{
	name: "CancelEventDefinition",
	superClass: [
		"EventDefinition"
	]
},
{
	name: "ErrorEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "errorRef",
			type: "Error",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "TerminateEventDefinition",
	superClass: [
		"EventDefinition"
	]
},
{
	name: "EscalationEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "escalationRef",
			type: "Escalation",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Escalation",
	properties: [
		{
			name: "structureRef",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "escalationCode",
			isAttr: true,
			type: "String"
		}
	],
	superClass: [
		"RootElement"
	]
},
{
	name: "CompensateEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "waitForCompletion",
			isAttr: true,
			type: "Boolean",
			"default": true
		},
		{
			name: "activityRef",
			type: "Activity",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "TimerEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "timeDate",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "timeCycle",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "timeDuration",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		}
	]
},
{
	name: "LinkEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "target",
			type: "LinkEventDefinition",
			isAttr: true,
			isReference: true
		},
		{
			name: "source",
			type: "LinkEventDefinition",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "MessageEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "messageRef",
			type: "Message",
			isAttr: true,
			isReference: true
		},
		{
			name: "operationRef",
			type: "Operation",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ConditionalEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "condition",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		}
	]
},
{
	name: "SignalEventDefinition",
	superClass: [
		"EventDefinition"
	],
	properties: [
		{
			name: "signalRef",
			type: "Signal",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Signal",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "structureRef",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ImplicitThrowEvent",
	superClass: [
		"ThrowEvent"
	]
},
{
	name: "DataState",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ItemAwareElement",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "itemSubjectRef",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		},
		{
			name: "dataState",
			type: "DataState"
		}
	]
},
{
	name: "DataAssociation",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "sourceRef",
			type: "ItemAwareElement",
			isMany: true,
			isReference: true
		},
		{
			name: "targetRef",
			type: "ItemAwareElement",
			isReference: true
		},
		{
			name: "transformation",
			type: "FormalExpression",
			xml: {
				serialize: "property"
			}
		},
		{
			name: "assignment",
			type: "Assignment",
			isMany: true
		}
	]
},
{
	name: "DataInput",
	superClass: [
		"ItemAwareElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "isCollection",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "inputSetRef",
			type: "InputSet",
			isMany: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "inputSetWithOptional",
			type: "InputSet",
			isMany: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "inputSetWithWhileExecuting",
			type: "InputSet",
			isMany: true,
			isVirtual: true,
			isReference: true
		}
	]
},
{
	name: "DataOutput",
	superClass: [
		"ItemAwareElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "isCollection",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "outputSetRef",
			type: "OutputSet",
			isMany: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "outputSetWithOptional",
			type: "OutputSet",
			isMany: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "outputSetWithWhileExecuting",
			type: "OutputSet",
			isMany: true,
			isVirtual: true,
			isReference: true
		}
	]
},
{
	name: "InputSet",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "dataInputRefs",
			type: "DataInput",
			isMany: true,
			isReference: true
		},
		{
			name: "optionalInputRefs",
			type: "DataInput",
			isMany: true,
			isReference: true
		},
		{
			name: "whileExecutingInputRefs",
			type: "DataInput",
			isMany: true,
			isReference: true
		},
		{
			name: "outputSetRefs",
			type: "OutputSet",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "OutputSet",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "dataOutputRefs",
			type: "DataOutput",
			isMany: true,
			isReference: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "inputSetRefs",
			type: "InputSet",
			isMany: true,
			isReference: true
		},
		{
			name: "optionalOutputRefs",
			type: "DataOutput",
			isMany: true,
			isReference: true
		},
		{
			name: "whileExecutingOutputRefs",
			type: "DataOutput",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "Property",
	superClass: [
		"ItemAwareElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "DataInputAssociation",
	superClass: [
		"DataAssociation"
	]
},
{
	name: "DataOutputAssociation",
	superClass: [
		"DataAssociation"
	]
},
{
	name: "InputOutputSpecification",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "dataInputs",
			type: "DataInput",
			isMany: true
		},
		{
			name: "dataOutputs",
			type: "DataOutput",
			isMany: true
		},
		{
			name: "inputSets",
			type: "InputSet",
			isMany: true
		},
		{
			name: "outputSets",
			type: "OutputSet",
			isMany: true
		}
	]
},
{
	name: "DataObject",
	superClass: [
		"FlowElement",
		"ItemAwareElement"
	],
	properties: [
		{
			name: "isCollection",
			"default": false,
			isAttr: true,
			type: "Boolean"
		}
	]
},
{
	name: "InputOutputBinding",
	properties: [
		{
			name: "inputDataRef",
			type: "InputSet",
			isAttr: true,
			isReference: true
		},
		{
			name: "outputDataRef",
			type: "OutputSet",
			isAttr: true,
			isReference: true
		},
		{
			name: "operationRef",
			type: "Operation",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Assignment",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "from",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "to",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		}
	]
},
{
	name: "DataStore",
	superClass: [
		"RootElement",
		"ItemAwareElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "capacity",
			isAttr: true,
			type: "Integer"
		},
		{
			name: "isUnlimited",
			"default": true,
			isAttr: true,
			type: "Boolean"
		}
	]
},
{
	name: "DataStoreReference",
	superClass: [
		"ItemAwareElement",
		"FlowElement"
	],
	properties: [
		{
			name: "dataStoreRef",
			type: "DataStore",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "DataObjectReference",
	superClass: [
		"ItemAwareElement",
		"FlowElement"
	],
	properties: [
		{
			name: "dataObjectRef",
			type: "DataObject",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ConversationLink",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "sourceRef",
			type: "InteractionNode",
			isAttr: true,
			isReference: true
		},
		{
			name: "targetRef",
			type: "InteractionNode",
			isAttr: true,
			isReference: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ConversationAssociation",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "innerConversationNodeRef",
			type: "ConversationNode",
			isAttr: true,
			isReference: true
		},
		{
			name: "outerConversationNodeRef",
			type: "ConversationNode",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "CallConversation",
	superClass: [
		"ConversationNode"
	],
	properties: [
		{
			name: "calledCollaborationRef",
			type: "Collaboration",
			isAttr: true,
			isReference: true
		},
		{
			name: "participantAssociations",
			type: "ParticipantAssociation",
			isMany: true
		}
	]
},
{
	name: "Conversation",
	superClass: [
		"ConversationNode"
	]
},
{
	name: "SubConversation",
	superClass: [
		"ConversationNode"
	],
	properties: [
		{
			name: "conversationNodes",
			type: "ConversationNode",
			isMany: true
		}
	]
},
{
	name: "ConversationNode",
	isAbstract: true,
	superClass: [
		"InteractionNode",
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "participantRef",
			type: "Participant",
			isMany: true,
			isReference: true
		},
		{
			name: "messageFlowRefs",
			type: "MessageFlow",
			isMany: true,
			isReference: true
		},
		{
			name: "correlationKeys",
			type: "CorrelationKey",
			isMany: true
		}
	]
},
{
	name: "GlobalConversation",
	superClass: [
		"Collaboration"
	]
},
{
	name: "PartnerEntity",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "participantRef",
			type: "Participant",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "PartnerRole",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "participantRef",
			type: "Participant",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "CorrelationProperty",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "correlationPropertyRetrievalExpression",
			type: "CorrelationPropertyRetrievalExpression",
			isMany: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "type",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Error",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "structureRef",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "errorCode",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "CorrelationKey",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "correlationPropertyRef",
			type: "CorrelationProperty",
			isMany: true,
			isReference: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Expression",
	superClass: [
		"BaseElement"
	],
	isAbstract: false,
	properties: [
		{
			name: "body",
			isBody: true,
			type: "String"
		}
	]
},
{
	name: "FormalExpression",
	superClass: [
		"Expression"
	],
	properties: [
		{
			name: "language",
			isAttr: true,
			type: "String"
		},
		{
			name: "evaluatesToTypeRef",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Message",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "itemRef",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ItemDefinition",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "itemKind",
			type: "ItemKind",
			isAttr: true
		},
		{
			name: "structureRef",
			isAttr: true,
			type: "String"
		},
		{
			name: "isCollection",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "import",
			type: "Import",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "FlowElement",
	isAbstract: true,
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "auditing",
			type: "Auditing"
		},
		{
			name: "monitoring",
			type: "Monitoring"
		},
		{
			name: "categoryValueRef",
			type: "CategoryValue",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "SequenceFlow",
	superClass: [
		"FlowElement"
	],
	properties: [
		{
			name: "isImmediate",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "conditionExpression",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "sourceRef",
			type: "FlowNode",
			isAttr: true,
			isReference: true
		},
		{
			name: "targetRef",
			type: "FlowNode",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "FlowElementsContainer",
	isAbstract: true,
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "laneSets",
			type: "LaneSet",
			isMany: true
		},
		{
			name: "flowElements",
			type: "FlowElement",
			isMany: true
		}
	]
},
{
	name: "CallableElement",
	isAbstract: true,
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "ioSpecification",
			type: "InputOutputSpecification",
			xml: {
				serialize: "property"
			}
		},
		{
			name: "supportedInterfaceRef",
			type: "Interface",
			isMany: true,
			isReference: true
		},
		{
			name: "ioBinding",
			type: "InputOutputBinding",
			isMany: true,
			xml: {
				serialize: "property"
			}
		}
	]
},
{
	name: "FlowNode",
	isAbstract: true,
	superClass: [
		"FlowElement"
	],
	properties: [
		{
			name: "incoming",
			type: "SequenceFlow",
			isMany: true,
			isReference: true
		},
		{
			name: "outgoing",
			type: "SequenceFlow",
			isMany: true,
			isReference: true
		},
		{
			name: "lanes",
			type: "Lane",
			isMany: true,
			isVirtual: true,
			isReference: true
		}
	]
},
{
	name: "CorrelationPropertyRetrievalExpression",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "messagePath",
			type: "FormalExpression"
		},
		{
			name: "messageRef",
			type: "Message",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "CorrelationPropertyBinding",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "dataPath",
			type: "FormalExpression"
		},
		{
			name: "correlationPropertyRef",
			type: "CorrelationProperty",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Resource",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "resourceParameters",
			type: "ResourceParameter",
			isMany: true
		}
	]
},
{
	name: "ResourceParameter",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "isRequired",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "type",
			type: "ItemDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "CorrelationSubscription",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "correlationKeyRef",
			type: "CorrelationKey",
			isAttr: true,
			isReference: true
		},
		{
			name: "correlationPropertyBinding",
			type: "CorrelationPropertyBinding",
			isMany: true
		}
	]
},
{
	name: "MessageFlow",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "sourceRef",
			type: "InteractionNode",
			isAttr: true,
			isReference: true
		},
		{
			name: "targetRef",
			type: "InteractionNode",
			isAttr: true,
			isReference: true
		},
		{
			name: "messageRef",
			type: "Message",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "MessageFlowAssociation",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "innerMessageFlowRef",
			type: "MessageFlow",
			isAttr: true,
			isReference: true
		},
		{
			name: "outerMessageFlowRef",
			type: "MessageFlow",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "InteractionNode",
	isAbstract: true,
	properties: [
		{
			name: "incomingConversationLinks",
			type: "ConversationLink",
			isMany: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "outgoingConversationLinks",
			type: "ConversationLink",
			isMany: true,
			isVirtual: true,
			isReference: true
		}
	]
},
{
	name: "Participant",
	superClass: [
		"InteractionNode",
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "interfaceRef",
			type: "Interface",
			isMany: true,
			isReference: true
		},
		{
			name: "participantMultiplicity",
			type: "ParticipantMultiplicity"
		},
		{
			name: "endPointRefs",
			type: "EndPoint",
			isMany: true,
			isReference: true
		},
		{
			name: "processRef",
			type: "Process",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ParticipantAssociation",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "innerParticipantRef",
			type: "Participant",
			isAttr: true,
			isReference: true
		},
		{
			name: "outerParticipantRef",
			type: "Participant",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ParticipantMultiplicity",
	properties: [
		{
			name: "minimum",
			"default": 0,
			isAttr: true,
			type: "Integer"
		},
		{
			name: "maximum",
			"default": 1,
			isAttr: true,
			type: "Integer"
		}
	],
	superClass: [
		"BaseElement"
	]
},
{
	name: "Collaboration",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "isClosed",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "participants",
			type: "Participant",
			isMany: true
		},
		{
			name: "messageFlows",
			type: "MessageFlow",
			isMany: true
		},
		{
			name: "artifacts",
			type: "Artifact",
			isMany: true
		},
		{
			name: "conversations",
			type: "ConversationNode",
			isMany: true
		},
		{
			name: "conversationAssociations",
			type: "ConversationAssociation"
		},
		{
			name: "participantAssociations",
			type: "ParticipantAssociation",
			isMany: true
		},
		{
			name: "messageFlowAssociations",
			type: "MessageFlowAssociation",
			isMany: true
		},
		{
			name: "correlationKeys",
			type: "CorrelationKey",
			isMany: true
		},
		{
			name: "choreographyRef",
			type: "Choreography",
			isMany: true,
			isReference: true
		},
		{
			name: "conversationLinks",
			type: "ConversationLink",
			isMany: true
		}
	]
},
{
	name: "ChoreographyActivity",
	isAbstract: true,
	superClass: [
		"FlowNode"
	],
	properties: [
		{
			name: "participantRef",
			type: "Participant",
			isMany: true,
			isReference: true
		},
		{
			name: "initiatingParticipantRef",
			type: "Participant",
			isAttr: true,
			isReference: true
		},
		{
			name: "correlationKeys",
			type: "CorrelationKey",
			isMany: true
		},
		{
			name: "loopType",
			type: "ChoreographyLoopType",
			"default": "None",
			isAttr: true
		}
	]
},
{
	name: "CallChoreography",
	superClass: [
		"ChoreographyActivity"
	],
	properties: [
		{
			name: "calledChoreographyRef",
			type: "Choreography",
			isAttr: true,
			isReference: true
		},
		{
			name: "participantAssociations",
			type: "ParticipantAssociation",
			isMany: true
		}
	]
},
{
	name: "SubChoreography",
	superClass: [
		"ChoreographyActivity",
		"FlowElementsContainer"
	],
	properties: [
		{
			name: "artifacts",
			type: "Artifact",
			isMany: true
		}
	]
},
{
	name: "ChoreographyTask",
	superClass: [
		"ChoreographyActivity"
	],
	properties: [
		{
			name: "messageFlowRef",
			type: "MessageFlow",
			isMany: true,
			isReference: true
		}
	]
},
{
	name: "Choreography",
	superClass: [
		"Collaboration",
		"FlowElementsContainer"
	]
},
{
	name: "GlobalChoreographyTask",
	superClass: [
		"Choreography"
	],
	properties: [
		{
			name: "initiatingParticipantRef",
			type: "Participant",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "TextAnnotation",
	superClass: [
		"Artifact"
	],
	properties: [
		{
			name: "text",
			type: "String"
		},
		{
			name: "textFormat",
			"default": "text/plain",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Group",
	superClass: [
		"Artifact"
	],
	properties: [
		{
			name: "categoryValueRef",
			type: "CategoryValue",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Association",
	superClass: [
		"Artifact"
	],
	properties: [
		{
			name: "associationDirection",
			type: "AssociationDirection",
			isAttr: true
		},
		{
			name: "sourceRef",
			type: "BaseElement",
			isAttr: true,
			isReference: true
		},
		{
			name: "targetRef",
			type: "BaseElement",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "Category",
	superClass: [
		"RootElement"
	],
	properties: [
		{
			name: "categoryValue",
			type: "CategoryValue",
			isMany: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Artifact",
	isAbstract: true,
	superClass: [
		"BaseElement"
	]
},
{
	name: "CategoryValue",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "categorizedFlowElements",
			type: "FlowElement",
			isMany: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "value",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Activity",
	isAbstract: true,
	superClass: [
		"FlowNode"
	],
	properties: [
		{
			name: "isForCompensation",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "default",
			type: "SequenceFlow",
			isAttr: true,
			isReference: true
		},
		{
			name: "ioSpecification",
			type: "InputOutputSpecification",
			xml: {
				serialize: "property"
			}
		},
		{
			name: "boundaryEventRefs",
			type: "BoundaryEvent",
			isMany: true,
			isReference: true
		},
		{
			name: "properties",
			type: "Property",
			isMany: true
		},
		{
			name: "dataInputAssociations",
			type: "DataInputAssociation",
			isMany: true
		},
		{
			name: "dataOutputAssociations",
			type: "DataOutputAssociation",
			isMany: true
		},
		{
			name: "startQuantity",
			"default": 1,
			isAttr: true,
			type: "Integer"
		},
		{
			name: "resources",
			type: "ResourceRole",
			isMany: true
		},
		{
			name: "completionQuantity",
			"default": 1,
			isAttr: true,
			type: "Integer"
		},
		{
			name: "loopCharacteristics",
			type: "LoopCharacteristics"
		}
	]
},
{
	name: "ServiceTask",
	superClass: [
		"Task"
	],
	properties: [
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		},
		{
			name: "operationRef",
			type: "Operation",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "SubProcess",
	superClass: [
		"Activity",
		"FlowElementsContainer",
		"InteractionNode"
	],
	properties: [
		{
			name: "triggeredByEvent",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "artifacts",
			type: "Artifact",
			isMany: true
		}
	]
},
{
	name: "LoopCharacteristics",
	isAbstract: true,
	superClass: [
		"BaseElement"
	]
},
{
	name: "MultiInstanceLoopCharacteristics",
	superClass: [
		"LoopCharacteristics"
	],
	properties: [
		{
			name: "isSequential",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "behavior",
			type: "MultiInstanceBehavior",
			"default": "All",
			isAttr: true
		},
		{
			name: "loopCardinality",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "loopDataInputRef",
			type: "ItemAwareElement",
			isReference: true
		},
		{
			name: "loopDataOutputRef",
			type: "ItemAwareElement",
			isReference: true
		},
		{
			name: "inputDataItem",
			type: "DataInput",
			xml: {
				serialize: "property"
			}
		},
		{
			name: "outputDataItem",
			type: "DataOutput",
			xml: {
				serialize: "property"
			}
		},
		{
			name: "complexBehaviorDefinition",
			type: "ComplexBehaviorDefinition",
			isMany: true
		},
		{
			name: "completionCondition",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "oneBehaviorEventRef",
			type: "EventDefinition",
			isAttr: true,
			isReference: true
		},
		{
			name: "noneBehaviorEventRef",
			type: "EventDefinition",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "StandardLoopCharacteristics",
	superClass: [
		"LoopCharacteristics"
	],
	properties: [
		{
			name: "testBefore",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "loopCondition",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "loopMaximum",
			type: "Integer",
			isAttr: true
		}
	]
},
{
	name: "CallActivity",
	superClass: [
		"Activity",
		"InteractionNode"
	],
	properties: [
		{
			name: "calledElement",
			type: "String",
			isAttr: true
		}
	]
},
{
	name: "Task",
	superClass: [
		"Activity",
		"InteractionNode"
	]
},
{
	name: "SendTask",
	superClass: [
		"Task"
	],
	properties: [
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		},
		{
			name: "operationRef",
			type: "Operation",
			isAttr: true,
			isReference: true
		},
		{
			name: "messageRef",
			type: "Message",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ReceiveTask",
	superClass: [
		"Task"
	],
	properties: [
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		},
		{
			name: "instantiate",
			"default": false,
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "operationRef",
			type: "Operation",
			isAttr: true,
			isReference: true
		},
		{
			name: "messageRef",
			type: "Message",
			isAttr: true,
			isReference: true
		}
	]
},
{
	name: "ScriptTask",
	superClass: [
		"Task"
	],
	properties: [
		{
			name: "scriptFormat",
			isAttr: true,
			type: "String"
		},
		{
			name: "script",
			type: "String"
		}
	]
},
{
	name: "BusinessRuleTask",
	superClass: [
		"Task"
	],
	properties: [
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "AdHocSubProcess",
	superClass: [
		"SubProcess"
	],
	properties: [
		{
			name: "completionCondition",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "ordering",
			type: "AdHocOrdering",
			isAttr: true
		},
		{
			name: "cancelRemainingInstances",
			"default": true,
			isAttr: true,
			type: "Boolean"
		}
	]
},
{
	name: "Transaction",
	superClass: [
		"SubProcess"
	],
	properties: [
		{
			name: "protocol",
			isAttr: true,
			type: "String"
		},
		{
			name: "method",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "GlobalScriptTask",
	superClass: [
		"GlobalTask"
	],
	properties: [
		{
			name: "scriptLanguage",
			isAttr: true,
			type: "String"
		},
		{
			name: "script",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "GlobalBusinessRuleTask",
	superClass: [
		"GlobalTask"
	],
	properties: [
		{
			name: "implementation",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ComplexBehaviorDefinition",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "condition",
			type: "FormalExpression"
		},
		{
			name: "event",
			type: "ImplicitThrowEvent"
		}
	]
},
{
	name: "ResourceRole",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "resourceRef",
			type: "Resource",
			isReference: true
		},
		{
			name: "resourceParameterBindings",
			type: "ResourceParameterBinding",
			isMany: true
		},
		{
			name: "resourceAssignmentExpression",
			type: "ResourceAssignmentExpression"
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ResourceParameterBinding",
	properties: [
		{
			name: "expression",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		},
		{
			name: "parameterRef",
			type: "ResourceParameter",
			isAttr: true,
			isReference: true
		}
	],
	superClass: [
		"BaseElement"
	]
},
{
	name: "ResourceAssignmentExpression",
	properties: [
		{
			name: "expression",
			type: "Expression",
			xml: {
				serialize: "xsi:type"
			}
		}
	],
	superClass: [
		"BaseElement"
	]
},
{
	name: "Import",
	properties: [
		{
			name: "importType",
			isAttr: true,
			type: "String"
		},
		{
			name: "location",
			isAttr: true,
			type: "String"
		},
		{
			name: "namespace",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "Definitions",
	superClass: [
		"BaseElement"
	],
	properties: [
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "targetNamespace",
			isAttr: true,
			type: "String"
		},
		{
			name: "expressionLanguage",
			"default": "http://www.w3.org/1999/XPath",
			isAttr: true,
			type: "String"
		},
		{
			name: "typeLanguage",
			"default": "http://www.w3.org/2001/XMLSchema",
			isAttr: true,
			type: "String"
		},
		{
			name: "imports",
			type: "Import",
			isMany: true
		},
		{
			name: "extensions",
			type: "Extension",
			isMany: true
		},
		{
			name: "rootElements",
			type: "RootElement",
			isMany: true
		},
		{
			name: "diagrams",
			isMany: true,
			type: "bpmndi:BPMNDiagram"
		},
		{
			name: "exporter",
			isAttr: true,
			type: "String"
		},
		{
			name: "relationships",
			type: "Relationship",
			isMany: true
		},
		{
			name: "exporterVersion",
			isAttr: true,
			type: "String"
		}
	]
}
];
var enumerations = [
{
	name: "ProcessType",
	literalValues: [
		{
			name: "None"
		},
		{
			name: "Public"
		},
		{
			name: "Private"
		}
	]
},
{
	name: "GatewayDirection",
	literalValues: [
		{
			name: "Unspecified"
		},
		{
			name: "Converging"
		},
		{
			name: "Diverging"
		},
		{
			name: "Mixed"
		}
	]
},
{
	name: "EventBasedGatewayType",
	literalValues: [
		{
			name: "Parallel"
		},
		{
			name: "Exclusive"
		}
	]
},
{
	name: "RelationshipDirection",
	literalValues: [
		{
			name: "None"
		},
		{
			name: "Forward"
		},
		{
			name: "Backward"
		},
		{
			name: "Both"
		}
	]
},
{
	name: "ItemKind",
	literalValues: [
		{
			name: "Physical"
		},
		{
			name: "Information"
		}
	]
},
{
	name: "ChoreographyLoopType",
	literalValues: [
		{
			name: "None"
		},
		{
			name: "Standard"
		},
		{
			name: "MultiInstanceSequential"
		},
		{
			name: "MultiInstanceParallel"
		}
	]
},
{
	name: "AssociationDirection",
	literalValues: [
		{
			name: "None"
		},
		{
			name: "One"
		},
		{
			name: "Both"
		}
	]
},
{
	name: "MultiInstanceBehavior",
	literalValues: [
		{
			name: "None"
		},
		{
			name: "One"
		},
		{
			name: "All"
		},
		{
			name: "Complex"
		}
	]
},
{
	name: "AdHocOrdering",
	literalValues: [
		{
			name: "Parallel"
		},
		{
			name: "Sequential"
		}
	]
}
];
var xml = {
tagAlias: "lowerCase",
typePrefix: "t"
};
var BpmnPackage = {
name: name,
uri: uri,
prefix: prefix,
associations: associations,
types: types,
enumerations: enumerations,
xml: xml
};
15067
var name$1 = "BPMNDI";
var uri$1 = "http://www.omg.org/spec/BPMN/20100524/DI";
var prefix$1 = "bpmndi";
var types$1 = [
{
	name: "BPMNDiagram",
	properties: [
		{
			name: "plane",
			type: "BPMNPlane",
			redefines: "di:Diagram#rootElement"
		},
		{
			name: "labelStyle",
			type: "BPMNLabelStyle",
			isMany: true
		}
	],
	superClass: [
		"di:Diagram"
	]
},
{
	name: "BPMNPlane",
	properties: [
		{
			name: "bpmnElement",
			isAttr: true,
			isReference: true,
			type: "bpmn:BaseElement",
			redefines: "di:DiagramElement#modelElement"
		}
	],
	superClass: [
		"di:Plane"
	]
},
{
	name: "BPMNShape",
	properties: [
		{
			name: "bpmnElement",
			isAttr: true,
			isReference: true,
			type: "bpmn:BaseElement",
			redefines: "di:DiagramElement#modelElement"
		},
		{
			name: "isHorizontal",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "isExpanded",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "isMarkerVisible",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "label",
			type: "BPMNLabel"
		},
		{
			name: "isMessageVisible",
			isAttr: true,
			type: "Boolean"
		},
		{
			name: "participantBandKind",
			type: "ParticipantBandKind",
			isAttr: true
		},
		{
			name: "choreographyActivityShape",
			type: "BPMNShape",
			isAttr: true,
			isReference: true
		}
	],
	superClass: [
		"di:LabeledShape"
	]
},
{
	name: "BPMNEdge",
	properties: [
		{
			name: "label",
			type: "BPMNLabel"
		},
		{
			name: "bpmnElement",
			isAttr: true,
			isReference: true,
			type: "bpmn:BaseElement",
			redefines: "di:DiagramElement#modelElement"
		},
		{
			name: "sourceElement",
			isAttr: true,
			isReference: true,
			type: "di:DiagramElement",
			redefines: "di:Edge#source"
		},
		{
			name: "targetElement",
			isAttr: true,
			isReference: true,
			type: "di:DiagramElement",
			redefines: "di:Edge#target"
		},
		{
			name: "messageVisibleKind",
			type: "MessageVisibleKind",
			isAttr: true,
			"default": "initiating"
		}
	],
	superClass: [
		"di:LabeledEdge"
	]
},
{
	name: "BPMNLabel",
	properties: [
		{
			name: "labelStyle",
			type: "BPMNLabelStyle",
			isAttr: true,
			isReference: true,
			redefines: "di:DiagramElement#style"
		}
	],
	superClass: [
		"di:Label"
	]
},
{
	name: "BPMNLabelStyle",
	properties: [
		{
			name: "font",
			type: "dc:Font"
		}
	],
	superClass: [
		"di:Style"
	]
}
];
var enumerations$1 = [
{
	name: "ParticipantBandKind",
	literalValues: [
		{
			name: "top_initiating"
		},
		{
			name: "middle_initiating"
		},
		{
			name: "bottom_initiating"
		},
		{
			name: "top_non_initiating"
		},
		{
			name: "middle_non_initiating"
		},
		{
			name: "bottom_non_initiating"
		}
	]
},
{
	name: "MessageVisibleKind",
	literalValues: [
		{
			name: "initiating"
		},
		{
			name: "non_initiating"
		}
	]
}
];
var associations$1 = [
];
var BpmnDiPackage = {
name: name$1,
uri: uri$1,
prefix: prefix$1,
types: types$1,
enumerations: enumerations$1,
associations: associations$1
};
15268
var name$2 = "DC";
var uri$2 = "http://www.omg.org/spec/DD/20100524/DC";
var prefix$2 = "dc";
var types$2 = [
{
	name: "Boolean"
},
{
	name: "Integer"
},
{
	name: "Real"
},
{
	name: "String"
},
{
	name: "Font",
	properties: [
		{
			name: "name",
			type: "String",
			isAttr: true
		},
		{
			name: "size",
			type: "Real",
			isAttr: true
		},
		{
			name: "isBold",
			type: "Boolean",
			isAttr: true
		},
		{
			name: "isItalic",
			type: "Boolean",
			isAttr: true
		},
		{
			name: "isUnderline",
			type: "Boolean",
			isAttr: true
		},
		{
			name: "isStrikeThrough",
			type: "Boolean",
			isAttr: true
		}
	]
},
{
	name: "Point",
	properties: [
		{
			name: "x",
			type: "Real",
			"default": "0",
			isAttr: true
		},
		{
			name: "y",
			type: "Real",
			"default": "0",
			isAttr: true
		}
	]
},
{
	name: "Bounds",
	properties: [
		{
			name: "x",
			type: "Real",
			"default": "0",
			isAttr: true
		},
		{
			name: "y",
			type: "Real",
			"default": "0",
			isAttr: true
		},
		{
			name: "width",
			type: "Real",
			isAttr: true
		},
		{
			name: "height",
			type: "Real",
			isAttr: true
		}
	]
}
];
var associations$2 = [
];
var DcPackage = {
name: name$2,
uri: uri$2,
prefix: prefix$2,
types: types$2,
associations: associations$2
};
15374
var name$3 = "DI";
var uri$3 = "http://www.omg.org/spec/DD/20100524/DI";
var prefix$3 = "di";
var types$3 = [
{
	name: "DiagramElement",
	isAbstract: true,
	properties: [
		{
			name: "id",
			isAttr: true,
			isId: true,
			type: "String"
		},
		{
			name: "extension",
			type: "Extension"
		},
		{
			name: "owningDiagram",
			type: "Diagram",
			isReadOnly: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "owningElement",
			type: "DiagramElement",
			isReadOnly: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "modelElement",
			isReadOnly: true,
			isVirtual: true,
			isReference: true,
			type: "Element"
		},
		{
			name: "style",
			type: "Style",
			isReadOnly: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "ownedElement",
			type: "DiagramElement",
			isReadOnly: true,
			isMany: true,
			isVirtual: true
		}
	]
},
{
	name: "Node",
	isAbstract: true,
	superClass: [
		"DiagramElement"
	]
},
{
	name: "Edge",
	isAbstract: true,
	superClass: [
		"DiagramElement"
	],
	properties: [
		{
			name: "source",
			type: "DiagramElement",
			isReadOnly: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "target",
			type: "DiagramElement",
			isReadOnly: true,
			isVirtual: true,
			isReference: true
		},
		{
			name: "waypoint",
			isUnique: false,
			isMany: true,
			type: "dc:Point",
			xml: {
				serialize: "xsi:type"
			}
		}
	]
},
{
	name: "Diagram",
	isAbstract: true,
	properties: [
		{
			name: "id",
			isAttr: true,
			isId: true,
			type: "String"
		},
		{
			name: "rootElement",
			type: "DiagramElement",
			isReadOnly: true,
			isVirtual: true
		},
		{
			name: "name",
			isAttr: true,
			type: "String"
		},
		{
			name: "documentation",
			isAttr: true,
			type: "String"
		},
		{
			name: "resolution",
			isAttr: true,
			type: "Real"
		},
		{
			name: "ownedStyle",
			type: "Style",
			isReadOnly: true,
			isMany: true,
			isVirtual: true
		}
	]
},
{
	name: "Shape",
	isAbstract: true,
	superClass: [
		"Node"
	],
	properties: [
		{
			name: "bounds",
			type: "dc:Bounds"
		}
	]
},
{
	name: "Plane",
	isAbstract: true,
	superClass: [
		"Node"
	],
	properties: [
		{
			name: "planeElement",
			type: "DiagramElement",
			subsettedProperty: "DiagramElement-ownedElement",
			isMany: true
		}
	]
},
{
	name: "LabeledEdge",
	isAbstract: true,
	superClass: [
		"Edge"
	],
	properties: [
		{
			name: "ownedLabel",
			type: "Label",
			isReadOnly: true,
			subsettedProperty: "DiagramElement-ownedElement",
			isMany: true,
			isVirtual: true
		}
	]
},
{
	name: "LabeledShape",
	isAbstract: true,
	superClass: [
		"Shape"
	],
	properties: [
		{
			name: "ownedLabel",
			type: "Label",
			isReadOnly: true,
			subsettedProperty: "DiagramElement-ownedElement",
			isMany: true,
			isVirtual: true
		}
	]
},
{
	name: "Label",
	isAbstract: true,
	superClass: [
		"Node"
	],
	properties: [
		{
			name: "bounds",
			type: "dc:Bounds"
		}
	]
},
{
	name: "Style",
	isAbstract: true,
	properties: [
		{
			name: "id",
			isAttr: true,
			isId: true,
			type: "String"
		}
	]
},
{
	name: "Extension",
	properties: [
		{
			name: "values",
			isMany: true,
			type: "Element"
		}
	]
}
];
var associations$3 = [
];
var xml$1 = {
tagAlias: "lowerCase"
};
var DiPackage = {
name: name$3,
uri: uri$3,
prefix: prefix$3,
types: types$3,
associations: associations$3,
xml: xml$1
};
15620
var name$4 = "bpmn.io colors for BPMN";
var uri$4 = "http://bpmn.io/schema/bpmn/biocolor/1.0";
var prefix$4 = "bioc";
var types$4 = [
{
	name: "ColoredShape",
	"extends": [
		"bpmndi:BPMNShape"
	],
	properties: [
		{
			name: "stroke",
			isAttr: true,
			type: "String"
		},
		{
			name: "fill",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ColoredEdge",
	"extends": [
		"bpmndi:BPMNEdge"
	],
	properties: [
		{
			name: "stroke",
			isAttr: true,
			type: "String"
		},
		{
			name: "fill",
			isAttr: true,
			type: "String"
		}
	]
}
];
var enumerations$2 = [
];
var associations$4 = [
];
var BiocPackage = {
name: name$4,
uri: uri$4,
prefix: prefix$4,
types: types$4,
enumerations: enumerations$2,
associations: associations$4
};
15674
var name$5 = "BPMN in Color";
var uri$5 = "http://www.omg.org/spec/BPMN/non-normative/color/1.0";
var prefix$5 = "color";
var types$5 = [
{
	name: "ColoredLabel",
	"extends": [
		"bpmndi:BPMNLabel"
	],
	properties: [
		{
			name: "color",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ColoredShape",
	"extends": [
		"bpmndi:BPMNShape"
	],
	properties: [
		{
			name: "background-color",
			isAttr: true,
			type: "String"
		},
		{
			name: "border-color",
			isAttr: true,
			type: "String"
		}
	]
},
{
	name: "ColoredEdge",
	"extends": [
		"bpmndi:BPMNEdge"
	],
	properties: [
		{
			name: "border-color",
			isAttr: true,
			type: "String"
		}
	]
}
];
var enumerations$3 = [
];
var associations$5 = [
];
var BpmnInColorPackage = {
name: name$5,
uri: uri$5,
prefix: prefix$5,
types: types$5,
enumerations: enumerations$3,
associations: associations$5
};
15736
var packages = {
 bpmn: BpmnPackage,
 bpmndi: BpmnDiPackage,
 dc: DcPackage,
 di: DiPackage,
 bioc: BiocPackage,
 color: BpmnInColorPackage
};
15745
function simple(additionalPackages, options) {
 var pks = assign({}, packages, additionalPackages);
15748
 return new BpmnModdle(pks, options);
}
15751
function elementToString(e) {
 if (!e) {
   return '<null>';
 }
15756
 return '<' + e.$type + (e.id ? ' id="' + e.id : '') + '" />';
}
15759
// TODO(nikku): remove with future bpmn-js version
15761
/**
* Wraps APIs to check:
*
* 1) If a callback is passed -> Warn users about callback deprecation.
* 2) If Promise class is implemented in current environment.
*
* @private
*/
function wrapForCompatibility(api) {
15771
 return function() {
15773
   if (!window.Promise) {
     throw new Error('Promises is not supported in this environment. Please polyfill Promise.');
   }
15777
   var argLen = arguments.length;
   if (argLen >= 1 && isFunction(arguments[argLen - 1])) {
15780
     var callback = arguments[argLen - 1];
15782
     console.warn(new Error(
       'Passing callbacks to ' + api.name + ' is deprecated and will be removed in a future major release. ' +
       'Please switch to promises: https://bpmn.io/l/moving-to-promises.html'
     ));
15787
     var argsWithoutCallback = Array.prototype.slice.call(arguments, 0, -1);
15789
     api.apply(this, argsWithoutCallback).then(function(result) {
15791
       var firstKey = Object.keys(result)[0];
15793
       // The APIs we are wrapping all resolve a single item depending on the API.
       // For instance, importXML resolves { warnings } and saveXML returns { xml }.
       // That's why we can call the callback with the first item of result.
       return callback(null, result[firstKey]);
15798
       // Passing a second paramter instead of catch because we don't want to
       // catch errors thrown by callback().
     }, function(err) {
15802
       return callback(err, err.warnings);
     });
   } else {
15806
     return api.apply(this, arguments);
   }
 };
}
15811
15812
// TODO(nikku): remove with future bpmn-js version
15814
var DI_ERROR_MESSAGE = 'Tried to access di from the businessObject. The di is available through the diagram element only. For more information, see https://github.com/bpmn-io/bpmn-js/issues/1472';
15816
function ensureCompatDiRef(businessObject) {
15818
 // bpmnElement can have multiple independent DIs
 if (!has$2(businessObject, 'di')) {
   Object.defineProperty(businessObject, 'di', {
     get: function() {
       throw new Error(DI_ERROR_MESSAGE);
     }
   });
 }
}
15828
/**
* Returns true if an element has the given meta-model type
*
* @param  {ModdleElement}  element
* @param  {string}         type
*
* @return {boolean}
*/
function is$2(element, type) {
 return element.$instanceOf(type);
}
15840
15841
/**
* Find a suitable display candidate for definitions where the DI does not
* correctly specify one.
*/
function findDisplayCandidate(definitions) {
 return find(definitions.rootElements, function(e) {
   return is$2(e, 'bpmn:Process') || is$2(e, 'bpmn:Collaboration');
 });
}
15851
15852
function BpmnTreeWalker(handler, translate) {
15854
 // list of containers already walked
 var handledElements = {};
15857
 // list of elements to handle deferred to ensure
 // prerequisites are drawn
 var deferred = [];
15861
 var diMap = {};
15863
 // Helpers //////////////////////
15865
 function contextual(fn, ctx) {
   return function(e) {
     fn(e, ctx);
   };
 }
15871
 function handled(element) {
   handledElements[element.id] = element;
 }
15875
 function isHandled(element) {
   return handledElements[element.id];
 }
15879
 function visit(element, ctx) {
15881
   var gfx = element.gfx;
15883
   // avoid multiple rendering of elements
   if (gfx) {
     throw new Error(
       translate('already rendered {element}', { element: elementToString(element) })
     );
   }
15890
   // call handler
   return handler.element(element, diMap[element.id], ctx);
 }
15894
 function visitRoot(element, diagram) {
   return handler.root(element, diMap[element.id], diagram);
 }
15898
 function visitIfDi(element, ctx) {
15900
   try {
     var gfx = diMap[element.id] && visit(element, ctx);
15903
     handled(element);
15905
     return gfx;
   } catch (e) {
     logError(e.message, { element: element, error: e });
15909
     console.error(translate('failed to import {element}', { element: elementToString(element) }));
     console.error(e);
   }
 }
15914
 function logError(message, context) {
   handler.error(message, context);
 }
15918
 // DI handling //////////////////////
15920
 function registerDi(di) {
   var bpmnElement = di.bpmnElement;
15923
   if (bpmnElement) {
     if (diMap[bpmnElement.id]) {
       logError(
         translate('multiple DI elements defined for {element}', {
           element: elementToString(bpmnElement)
         }),
         { element: bpmnElement }
       );
     } else {
       diMap[bpmnElement.id] = di;
15934
       ensureCompatDiRef(bpmnElement);
     }
   } else {
     logError(
       translate('no bpmnElement referenced in {element}', {
         element: elementToString(di)
       }),
       { element: di }
     );
   }
 }
15946
 function handleDiagram(diagram) {
   handlePlane(diagram.plane);
 }
15950
 function handlePlane(plane) {
   registerDi(plane);
15953
   forEach$2(plane.planeElement, handlePlaneElement);
 }
15956
 function handlePlaneElement(planeElement) {
   registerDi(planeElement);
 }
15960
15961
 // Semantic handling //////////////////////
15963
 /**
  * Handle definitions and return the rendered diagram (if any)
  *
  * @param {ModdleElement} definitions to walk and import
  * @param {ModdleElement} [diagram] specific diagram to import and display
  *
  * @throws {Error} if no diagram to display could be found
  */
 function handleDefinitions(definitions, diagram) {
15973
   // make sure we walk the correct bpmnElement
15975
   var diagrams = definitions.diagrams;
15977
   if (diagram && diagrams.indexOf(diagram) === -1) {
     throw new Error(translate('diagram not part of bpmn:Definitions'));
   }
15981
   if (!diagram && diagrams && diagrams.length) {
     diagram = diagrams[0];
   }
15985
   // no diagram -> nothing to import
   if (!diagram) {
     throw new Error(translate('no diagram to display'));
   }
15990
   // load DI from selected diagram only
   diMap = {};
   handleDiagram(diagram);
15994
15995
   var plane = diagram.plane;
15997
   if (!plane) {
     throw new Error(translate(
       'no plane for {element}',
       { element: elementToString(diagram) }
     ));
   }
16004
   var rootElement = plane.bpmnElement;
16006
   // ensure we default to a suitable display candidate (process or collaboration),
   // even if non is specified in DI
   if (!rootElement) {
     rootElement = findDisplayCandidate(definitions);
16011
     if (!rootElement) {
       throw new Error(translate('no process or collaboration to display'));
     } else {
16015
       logError(
         translate('correcting missing bpmnElement on {plane} to {rootElement}', {
           plane: elementToString(plane),
           rootElement: elementToString(rootElement)
         })
       );
16022
       // correct DI on the fly
       plane.bpmnElement = rootElement;
       registerDi(plane);
     }
   }
16028
16029
   var ctx = visitRoot(rootElement, plane);
16031
   if (is$2(rootElement, 'bpmn:Process') || is$2(rootElement, 'bpmn:SubProcess')) {
     handleProcess(rootElement, ctx);
   } else if (is$2(rootElement, 'bpmn:Collaboration')) {
     handleCollaboration(rootElement, ctx);
16036
     // force drawing of everything not yet drawn that is part of the target DI
     handleUnhandledProcesses(definitions.rootElements, ctx);
   } else {
     throw new Error(
       translate('unsupported bpmnElement for {plane}: {rootElement}', {
         plane: elementToString(plane),
         rootElement: elementToString(rootElement)
       })
     );
   }
16047
   // handle all deferred elements
   handleDeferred();
 }
16051
 function handleDeferred() {
16053
   var fn;
16055
   // drain deferred until empty
   while (deferred.length) {
     fn = deferred.shift();
16059
     fn();
   }
 }
16063
 function handleProcess(process, context) {
   handleFlowElementsContainer(process, context);
   handleIoSpecification(process.ioSpecification, context);
16067
   handleArtifacts(process.artifacts, context);
16069
   // log process handled
   handled(process);
 }
16073
 function handleUnhandledProcesses(rootElements, ctx) {
16075
   // 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) {
     return !isHandled(e) && is$2(e, 'bpmn:Process') && e.laneSets;
   });
16082
   processes.forEach(contextual(handleProcess, ctx));
 }
16085
 function handleMessageFlow(messageFlow, context) {
   visitIfDi(messageFlow, context);
 }
16089
 function handleMessageFlows(messageFlows, context) {
   forEach$2(messageFlows, contextual(handleMessageFlow, context));
 }
16093
 function handleDataAssociation(association, context) {
   visitIfDi(association, context);
 }
16097
 function handleDataInput(dataInput, context) {
   visitIfDi(dataInput, context);
 }
16101
 function handleDataOutput(dataOutput, context) {
   visitIfDi(dataOutput, context);
 }
16105
 function handleArtifact(artifact, context) {
16107
   // bpmn:TextAnnotation
   // bpmn:Group
   // bpmn:Association
16111
   visitIfDi(artifact, context);
 }
16114
 function handleArtifacts(artifacts, context) {
16116
   forEach$2(artifacts, function(e) {
     if (is$2(e, 'bpmn:Association')) {
       deferred.push(function() {
         handleArtifact(e, context);
       });
     } else {
       handleArtifact(e, context);
     }
   });
 }
16127
 function handleIoSpecification(ioSpecification, context) {
16129
   if (!ioSpecification) {
     return;
   }
16133
   forEach$2(ioSpecification.dataInputs, contextual(handleDataInput, context));
   forEach$2(ioSpecification.dataOutputs, contextual(handleDataOutput, context));
 }
16137
 function handleSubProcess(subProcess, context) {
   handleFlowElementsContainer(subProcess, context);
   handleArtifacts(subProcess.artifacts, context);
 }
16142
 function handleFlowNode(flowNode, context) {
   var childCtx = visitIfDi(flowNode, context);
16145
   if (is$2(flowNode, 'bpmn:SubProcess')) {
     handleSubProcess(flowNode, childCtx || context);
   }
16149
   if (is$2(flowNode, 'bpmn:Activity')) {
     handleIoSpecification(flowNode.ioSpecification, context);
   }
16153
   // defer handling of associations
   // affected types:
   //
   //   * bpmn:Activity
   //   * bpmn:ThrowEvent
   //   * bpmn:CatchEvent
   //
   deferred.push(function() {
     forEach$2(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));
     forEach$2(flowNode.dataOutputAssociations, contextual(handleDataAssociation, context));
   });
 }
16166
 function handleSequenceFlow(sequenceFlow, context) {
   visitIfDi(sequenceFlow, context);
 }
16170
 function handleDataElement(dataObject, context) {
   visitIfDi(dataObject, context);
 }
16174
 function handleLane(lane, context) {
16176
   deferred.push(function() {
16178
     var newContext = visitIfDi(lane, context);
16180
     if (lane.childLaneSet) {
       handleLaneSet(lane.childLaneSet, newContext || context);
     }
16184
     wireFlowNodeRefs(lane);
   });
 }
16188
 function handleLaneSet(laneSet, context) {
   forEach$2(laneSet.lanes, contextual(handleLane, context));
 }
16192
 function handleLaneSets(laneSets, context) {
   forEach$2(laneSets, contextual(handleLaneSet, context));
 }
16196
 function handleFlowElementsContainer(container, context) {
   handleFlowElements(container.flowElements, context);
16199
   if (container.laneSets) {
     handleLaneSets(container.laneSets, context);
   }
 }
16204
 function handleFlowElements(flowElements, context) {
   forEach$2(flowElements, function(e) {
     if (is$2(e, 'bpmn:SequenceFlow')) {
       deferred.push(function() {
         handleSequenceFlow(e, context);
       });
     } else if (is$2(e, 'bpmn:BoundaryEvent')) {
       deferred.unshift(function() {
         handleFlowNode(e, context);
       });
     } else if (is$2(e, 'bpmn:FlowNode')) {
       handleFlowNode(e, context);
     } else if (is$2(e, 'bpmn:DataObject')) ; else if (is$2(e, 'bpmn:DataStoreReference')) {
       handleDataElement(e, context);
     } else if (is$2(e, 'bpmn:DataObjectReference')) {
       handleDataElement(e, context);
     } else {
       logError(
         translate('unrecognized flowElement {element} in context {context}', {
           element: elementToString(e),
           context: (context ? elementToString(context.businessObject) : 'null')
         }),
         { element: e, context: context }
       );
     }
   });
 }
16232
 function handleParticipant(participant, context) {
   var newCtx = visitIfDi(participant, context);
16235
   var process = participant.processRef;
   if (process) {
     handleProcess(process, newCtx || context);
   }
 }
16241
 function handleCollaboration(collaboration, context) {
16243
   forEach$2(collaboration.participants, contextual(handleParticipant, context));
16245
   handleArtifacts(collaboration.artifacts, context);
16247
   // handle message flows latest in the process
   deferred.push(function() {
     handleMessageFlows(collaboration.messageFlows, context);
   });
 }
16253
16254
 function wireFlowNodeRefs(lane) {
16256
   // wire the virtual flowNodeRefs <-> relationship
   forEach$2(lane.flowNodeRef, function(flowNode) {
     var lanes = flowNode.get('lanes');
16260
     if (lanes) {
       lanes.push(lane);
     }
   });
 }
16266
 // API //////////////////////
16268
 return {
   handleDeferred: handleDeferred,
   handleDefinitions: handleDefinitions,
   handleSubProcess: handleSubProcess,
   registerDi: registerDi
 };
}
16276
/**
* Is an element of the given BPMN type?
*
* @param  {djs.model.Base|ModdleElement} element
* @param  {string} type
*
* @return {boolean}
*/
function is$1(element, type) {
 var bo = getBusinessObject(element);
16287
 return bo && (typeof bo.$instanceOf === 'function') && bo.$instanceOf(type);
}
16290
16291
/**
* Return true if element has any of the given types.
*
* @param {djs.model.Base} element
* @param {Array<string>} types
*
* @return {boolean}
*/
function isAny(element, types) {
 return some(types, function(t) {
   return is$1(element, t);
 });
}
16305
/**
* Return the business object for a given element.
*
* @param  {djs.model.Base|ModdleElement} element
*
* @return {ModdleElement}
*/
function getBusinessObject(element) {
 return (element && element.businessObject) || element;
}
16316
/**
* Return the di object for a given element.
*
* @param  {djs.model.Base} element
*
* @return {ModdleElement}
*/
function getDi(element) {
 return element && element.di;
}
16327
/**
* The importBpmnDiagram result.
*
* @typedef {Object} ImportBPMNDiagramResult
*
* @property {Array<string>} warnings
*/
16335
/**
* The importBpmnDiagram error.
*
* @typedef {Error} ImportBPMNDiagramError
*
* @property {Array<string>} warnings
*/
16343
/**
* Import the definitions into a diagram.
*
* Errors and warnings are reported through the specified callback.
*
* @param  {djs.Diagram} diagram
* @param  {ModdleElement<Definitions>} definitions
* @param  {ModdleElement<BPMNDiagram>} [bpmnDiagram] the diagram to be rendered
* (if not provided, the first one will be rendered)
*
* Returns {Promise<ImportBPMNDiagramResult, ImportBPMNDiagramError>}
*/
function importBpmnDiagram(diagram, definitions, bpmnDiagram) {
16357
 var importer,
     eventBus,
     translate,
     canvas;
16362
 var error,
     warnings = [];
16365
 /**
  * Walk the diagram semantically, importing (=drawing)
  * all elements you encounter.
  *
  * @param {ModdleElement<Definitions>} definitions
  * @param {ModdleElement<BPMNDiagram>} bpmnDiagram
  */
 function render(definitions, bpmnDiagram) {
16374
   var visitor = {
16376
     root: function(element, di) {
       return importer.add(element, di);
     },
16380
     element: function(element, di, parentShape) {
       return importer.add(element, di, parentShape);
     },
16384
     error: function(message, context) {
       warnings.push({ message: message, context: context });
     }
   };
16389
   var walker = new BpmnTreeWalker(visitor, translate);
16391
16392
   bpmnDiagram = bpmnDiagram || (definitions.diagrams && definitions.diagrams[0]);
16394
   var diagramsToImport = getDiagramsToImport(definitions, bpmnDiagram);
16396
   if (!diagramsToImport) {
     throw new Error(translate('no diagram to display'));
   }
16400
   // traverse BPMN 2.0 document model,
   // starting at definitions
   forEach$2(diagramsToImport, function(diagram) {
     walker.handleDefinitions(definitions, diagram);
   });
16406
   var rootId = bpmnDiagram.plane.bpmnElement.id;
16408
   // we do need to account for different ways we create root elements
   // each nested imported <root> do have the `_plane` suffix, while
   // the root <root> is found under the business object ID
   canvas.setRootElement(
     canvas.findRoot(rootId + '_plane') || canvas.findRoot(rootId)
   );
 }
16416
 return new Promise(function(resolve, reject) {
   try {
     importer = diagram.get('bpmnImporter');
     eventBus = diagram.get('eventBus');
     translate = diagram.get('translate');
     canvas = diagram.get('canvas');
16423
     eventBus.fire('import.render.start', { definitions: definitions });
16425
     render(definitions, bpmnDiagram);
16427
     eventBus.fire('import.render.complete', {
       error: error,
       warnings: warnings
     });
16432
     return resolve({ warnings: warnings });
   } catch (e) {
16435
     e.warnings = warnings;
     return reject(e);
   }
 });
}
16441
/**
* Returns all diagrams in the same hierarchy as the requested diagram.
* Includes all parent and sub process diagrams.
*
* @param {Array} definitions
* @param {Object} bpmnDiagram
*
* @returns {Array<Object>}
*/
function getDiagramsToImport(definitions, bpmnDiagram) {
 if (!bpmnDiagram) {
   return;
 }
16455
 var bpmnElement = bpmnDiagram.plane.bpmnElement,
     rootElement = bpmnElement;
16458
 if (!is$1(bpmnElement, 'bpmn:Process') && !is$1(bpmnElement, 'bpmn:Collaboration')) {
   rootElement = findRootProcess(bpmnElement);
 }
16462
 // in case the process is part of a collaboration, the plane references the
 // collaboration, not the process
 var collaboration;
16466
 if (is$1(rootElement, 'bpmn:Collaboration')) {
   collaboration = rootElement;
 } else {
   collaboration = find(definitions.rootElements, function(element) {
     if (!is$1(element, 'bpmn:Collaboration')) {
       return;
     }
16474
     return find(element.participants, function(participant) {
       return participant.processRef === rootElement;
     });
   });
 }
16480
 var rootElements = [ rootElement ];
16482
 // all collaboration processes can contain sub-diagrams
 if (collaboration) {
   rootElements = map(collaboration.participants, function(participant) {
     return participant.processRef;
   });
16488
   rootElements.push(collaboration);
 }
16491
 var allChildren = selfAndAllFlowElements(rootElements);
16493
 // if we have multiple diagrams referencing the same element, we
 // use the first in the file
 var diagramsToImport = [ bpmnDiagram ];
 var handledElements = [ bpmnElement ];
16498
 forEach$2(definitions.diagrams, function(diagram) {
   var businessObject = diagram.plane.bpmnElement;
16501
   if (
     allChildren.indexOf(businessObject) !== -1 &&
     handledElements.indexOf(businessObject) === -1
   ) {
     diagramsToImport.push(diagram);
     handledElements.push(businessObject);
   }
 });
16510
16511
 return diagramsToImport;
}
16514
function selfAndAllFlowElements(elements) {
 var result = [];
16517
 forEach$2(elements, function(element) {
   if (!element) {
     return;
   }
16522
   result.push(element);
16524
   result = result.concat(selfAndAllFlowElements(element.flowElements));
 });
16527
 return result;
}
16530
function findRootProcess(element) {
 var parent = element;
16533
 while (parent) {
   if (is$1(parent, 'bpmn:Process')) {
     return parent;
   }
16538
   parent = parent.$parent;
 }
}
16542
/**
* This file must not be changed or exchanged.
*
* @see http://bpmn.io/license for more information.
*/
16548
16549
// inlined ../../resources/logo.svg
var BPMNIO_LOGO_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 14.02 5.57" width="53" height="21"><path fill="currentColor" d="M1.88.92v.14c0 .41-.13.68-.4.8.33.14.46.44.46.86v.33c0 .61-.33.95-.95.95H0V0h.95c.65 0 .93.3.93.92zM.63.57v1.06h.24c.24 0 .38-.1.38-.43V.98c0-.28-.1-.4-.32-.4zm0 1.63v1.22h.36c.2 0 .32-.1.32-.39v-.35c0-.37-.12-.48-.4-.48H.63zM4.18.99v.52c0 .64-.31.98-.94.98h-.3V4h-.62V0h.92c.63 0 .94.35.94.99zM2.94.57v1.35h.3c.2 0 .3-.09.3-.37v-.6c0-.29-.1-.38-.3-.38h-.3zm2.89 2.27L6.25 0h.88v4h-.6V1.12L6.1 3.99h-.6l-.46-2.82v2.82h-.55V0h.87zM8.14 1.1V4h-.56V0h.79L9 2.4V0h.56v4h-.64zm2.49 2.29v.6h-.6v-.6zM12.12 1c0-.63.33-1 .95-1 .61 0 .95.37.95 1v2.04c0 .64-.34 1-.95 1-.62 0-.95-.37-.95-1zm.62 2.08c0 .28.13.39.33.39s.32-.1.32-.4V.98c0-.29-.12-.4-.32-.4s-.33.11-.33.4z"/><path fill="currentColor" d="M0 4.53h14.02v1.04H0zM11.08 0h.63v.62h-.63zm.63 4V1h-.63v2.98z"/></svg>';
16552
var BPMNIO_IMG = BPMNIO_LOGO_SVG;
16554
var LOGO_STYLES = {
 verticalAlign: 'middle'
};
16558
var LINK_STYLES = {
 'color': '#404040'
};
16562
var LIGHTBOX_STYLES = {
 'zIndex': '1001',
 'position': 'fixed',
 'top': '0',
 'left': '0',
 'right': '0',
 'bottom': '0'
};
16571
var BACKDROP_STYLES = {
 'width': '100%',
 'height': '100%',
 'background': 'rgba(40,40,40,0.2)'
};
16577
var NOTICE_STYLES = {
 'position': 'absolute',
 'left': '50%',
 'top': '40%',
 'transform': 'translate(-50%)',
 'width': '260px',
 'padding': '10px',
 'background': 'white',
 'boxShadow': '0 1px 4px rgba(0,0,0,0.3)',
 'fontFamily': 'Helvetica, Arial, sans-serif',
 'fontSize': '14px',
 'display': 'flex',
 'lineHeight': '1.3'
};
16592
var LIGHTBOX_MARKUP =
 '<div class="bjs-powered-by-lightbox">' +
   '<div class="backdrop"></div>' +
   '<div class="notice">' +
     '<a href="https://bpmn.io" target="_blank" rel="noopener" class="link">' +
       BPMNIO_IMG +
     '</a>' +
     '<span>' +
       'Web-based tooling for BPMN, DMN and CMMN diagrams ' +
       'powered by <a href="https://bpmn.io" target="_blank" rel="noopener">bpmn.io</a>.' +
     '</span>' +
   '</div>' +
 '</div>';
16606
16607
var lightbox;
16609
function createLightbox() {
 lightbox = domify$1(LIGHTBOX_MARKUP);
16612
 assign$1$1(lightbox, LIGHTBOX_STYLES);
 assign$1$1(query$1('svg', lightbox), LOGO_STYLES);
 assign$1$1(query$1('.backdrop', lightbox), BACKDROP_STYLES);
 assign$1$1(query$1('.notice', lightbox), NOTICE_STYLES);
 assign$1$1(query$1('.link', lightbox), LINK_STYLES, {
   'margin': '15px 20px 15px 10px',
   'alignSelf': 'center'
 });
}
16622
function open() {
16624
 if (!lightbox) {
   createLightbox();
16627
   delegate$1.bind(lightbox, '.backdrop', 'click', function(event) {
     document.body.removeChild(lightbox);
   });
 }
16632
 document.body.appendChild(lightbox);
}
16635
/**
* The code in the <project-logo></project-logo> area
* must not be changed.
*
* @see http://bpmn.io/license for more information.
*/
16642
/**
* A base viewer for BPMN 2.0 diagrams.
*
* Have a look at {@link Viewer}, {@link NavigatedViewer} or {@link Modeler} for
* bundles that include actual features.
*
* @param {Object} [options] configuration options to pass to the viewer
* @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.
* @param {string|number} [options.width] the width of the viewer
* @param {string|number} [options.height] the height of the viewer
* @param {Object} [options.moddleExtensions] extension packages to provide
* @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules
* @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules
*/
function BaseViewer(options) {
16658
 options = assign({}, DEFAULT_OPTIONS, options);
16660
 this._moddle = this._createModdle(options);
16662
 this._container = this._createContainer(options);
16664
 /* <project-logo> */
16666
 addProjectLogo(this._container);
16668
 /* </project-logo> */
16670
 this._init(this._container, this._moddle, options);
}
16673
inherits$1(BaseViewer, Diagram);
16675
/**
* The importXML result.
*
* @typedef {Object} ImportXMLResult
*
* @property {Array<string>} warnings
*/
16683
/**
* The importXML error.
*
* @typedef {Error} ImportXMLError
*
* @property {Array<string>} warnings
*/
16691
/**
* Parse and render a BPMN 2.0 diagram.
*
* Once finished the viewer reports back the result to the
* provided callback function with (err, warnings).
*
* ## Life-Cycle Events
*
* During import the viewer will fire life-cycle events:
*
*   * import.parse.start (about to read model from xml)
*   * import.parse.complete (model read; may have worked or not)
*   * import.render.start (graphical import start)
*   * import.render.complete (graphical import finished)
*   * import.done (everything done)
*
* You can use these events to hook into the life-cycle.
*
* @param {string} xml the BPMN 2.0 xml
* @param {ModdleElement<BPMNDiagram>|string} [bpmnDiagram] BPMN diagram or id of diagram to render (if not provided, the first one will be rendered)
*
* Returns {Promise<ImportXMLResult, ImportXMLError>}
*/
BaseViewer.prototype.importXML = wrapForCompatibility(function importXML(xml, bpmnDiagram) {
16716
 var self = this;
16718
 function ParseCompleteEvent(data) {
16720
   var event = self.get('eventBus').createEvent(data);
16722
   // TODO(nikku): remove with future bpmn-js version
   Object.defineProperty(event, 'context', {
     enumerable: true,
     get: function() {
16727
       console.warn(new Error(
         'import.parse.complete <context> is deprecated ' +
         'and will be removed in future library versions'
       ));
16732
       return {
         warnings: data.warnings,
         references: data.references,
         elementsById: data.elementsById
       };
     }
   });
16740
   return event;
 }
16743
 return new Promise(function(resolve, reject) {
16745
   // hook in pre-parse listeners +
   // allow xml manipulation
   xml = self._emit('import.parse.start', { xml: xml }) || xml;
16749
   self._moddle.fromXML(xml, 'bpmn:Definitions').then(function(result) {
     var definitions = result.rootElement;
     var references = result.references;
     var parseWarnings = result.warnings;
     var elementsById = result.elementsById;
16755
     // hook in post parse listeners +
     // allow definitions manipulation
     definitions = self._emit('import.parse.complete', ParseCompleteEvent({
       error: null,
       definitions: definitions,
       elementsById: elementsById,
       references: references,
       warnings: parseWarnings
     })) || definitions;
16765
     self.importDefinitions(definitions, bpmnDiagram).then(function(result) {
       var allWarnings = [].concat(parseWarnings, result.warnings || []);
16768
       self._emit('import.done', { error: null, warnings: allWarnings });
16770
       return resolve({ warnings: allWarnings });
     }).catch(function(err) {
       var allWarnings = [].concat(parseWarnings, err.warnings || []);
16774
       self._emit('import.done', { error: err, warnings: allWarnings });
16776
       return reject(addWarningsToError(err, allWarnings));
     });
   }).catch(function(err) {
16780
     self._emit('import.parse.complete', {
       error: err
     });
16784
     err = checkValidationError(err);
16786
     self._emit('import.done', { error: err, warnings: err.warnings });
16788
     return reject(err);
   });
 });
});
16793
/**
* The importDefinitions result.
*
* @typedef {Object} ImportDefinitionsResult
*
* @property {Array<string>} warnings
*/
16801
/**
* The importDefinitions error.
*
* @typedef {Error} ImportDefinitionsError
*
* @property {Array<string>} warnings
*/
16809
/**
* Import parsed definitions and render a BPMN 2.0 diagram.
*
* Once finished the viewer reports back the result to the
* provided callback function with (err, warnings).
*
* ## Life-Cycle Events
*
* During import the viewer will fire life-cycle events:
*
*   * import.render.start (graphical import start)
*   * import.render.complete (graphical import finished)
*
* You can use these events to hook into the life-cycle.
*
* @param {ModdleElement<Definitions>} definitions parsed BPMN 2.0 definitions
* @param {ModdleElement<BPMNDiagram>|string} [bpmnDiagram] BPMN diagram or id of diagram to render (if not provided, the first one will be rendered)
*
* Returns {Promise<ImportDefinitionsResult, ImportDefinitionsError>}
*/
BaseViewer.prototype.importDefinitions = wrapForCompatibility(function importDefinitions(definitions, bpmnDiagram) {
16831
 var self = this;
16833
 return new Promise(function(resolve, reject) {
16835
   self._setDefinitions(definitions);
16837
   self.open(bpmnDiagram).then(function(result) {
16839
     var warnings = result.warnings;
16841
     return resolve({ warnings: warnings });
   }).catch(function(err) {
16844
     return reject(err);
   });
 });
});
16849
/**
* The open result.
*
* @typedef {Object} OpenResult
*
* @property {Array<string>} warnings
*/
16857
/**
* The open error.
*
* @typedef {Error} OpenError
*
* @property {Array<string>} warnings
*/
16865
/**
* Open diagram of previously imported XML.
*
* Once finished the viewer reports back the result to the
* provided callback function with (err, warnings).
*
* ## Life-Cycle Events
*
* During switch the viewer will fire life-cycle events:
*
*   * import.render.start (graphical import start)
*   * import.render.complete (graphical import finished)
*
* You can use these events to hook into the life-cycle.
*
* @param {string|ModdleElement<BPMNDiagram>} [bpmnDiagramOrId] id or the diagram to open
*
* Returns {Promise<OpenResult, OpenError>}
*/
BaseViewer.prototype.open = wrapForCompatibility(function open(bpmnDiagramOrId) {
16886
 var definitions = this._definitions;
 var bpmnDiagram = bpmnDiagramOrId;
16889
 var self = this;
16891
 return new Promise(function(resolve, reject) {
   if (!definitions) {
     var err1 = new Error('no XML imported');
16895
     return reject(addWarningsToError(err1, []));
   }
16898
   if (typeof bpmnDiagramOrId === 'string') {
     bpmnDiagram = findBPMNDiagram(definitions, bpmnDiagramOrId);
16901
     if (!bpmnDiagram) {
       var err2 = new Error('BPMNDiagram <' + bpmnDiagramOrId + '> not found');
16904
       return reject(addWarningsToError(err2, []));
     }
   }
16908
   // clear existing rendered diagram
   // catch synchronous exceptions during #clear()
   try {
     self.clear();
   } catch (error) {
16914
     return reject(addWarningsToError(error, []));
   }
16917
   // perform graphical import
   importBpmnDiagram(self, definitions, bpmnDiagram).then(function(result) {
16920
     var warnings = result.warnings;
16922
     return resolve({ warnings: warnings });
   }).catch(function(err) {
16925
     return reject(err);
   });
 });
});
16930
/**
* The saveXML result.
*
* @typedef {Object} SaveXMLResult
*
* @property {string} xml
*/
16938
/**
* Export the currently displayed BPMN 2.0 diagram as
* a BPMN 2.0 XML document.
*
* ## Life-Cycle Events
*
* During XML saving the viewer will fire life-cycle events:
*
*   * saveXML.start (before serialization)
*   * saveXML.serialized (after xml generation)
*   * saveXML.done (everything done)
*
* You can use these events to hook into the life-cycle.
*
* @param {Object} [options] export options
* @param {boolean} [options.format=false] output formatted XML
* @param {boolean} [options.preamble=true] output preamble
*
* Returns {Promise<SaveXMLResult, Error>}
*/
BaseViewer.prototype.saveXML = wrapForCompatibility(function saveXML(options) {
16960
 options = options || {};
16962
 var self = this;
16964
 var definitions = this._definitions;
16966
 return new Promise(function(resolve) {
16968
   if (!definitions) {
     return resolve({
       error: new Error('no definitions loaded')
     });
   }
16974
   // allow to fiddle around with definitions
   definitions = self._emit('saveXML.start', {
     definitions: definitions
   }) || definitions;
16979
   self._moddle.toXML(definitions, options).then(function(result) {
16981
     var xml = result.xml;
16983
     xml = self._emit('saveXML.serialized', {
       xml: xml
     }) || xml;
16987
     return resolve({
       xml: xml
     });
   });
 }).catch(function(error) {
   return { error: error };
 }).then(function(result) {
16995
   self._emit('saveXML.done', result);
16997
   var error = result.error;
16999
   if (error) {
     return Promise.reject(error);
   }
17003
   return result;
 });
});
17007
/**
* The saveSVG result.
*
* @typedef {Object} SaveSVGResult
*
* @property {string} svg
*/
17015
/**
* Export the currently displayed BPMN 2.0 diagram as
* an SVG image.
*
* ## Life-Cycle Events
*
* During SVG saving the viewer will fire life-cycle events:
*
*   * saveSVG.start (before serialization)
*   * saveSVG.done (everything done)
*
* You can use these events to hook into the life-cycle.
*
* @param {Object} [options]
*
* Returns {Promise<SaveSVGResult, Error>}
*/
BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) {
17034
 var self = this;
17036
 return new Promise(function(resolve, reject) {
17038
   self._emit('saveSVG.start');
17040
   var svg, err;
17042
   try {
     var canvas = self.get('canvas');
17045
     var contentNode = canvas.getActiveLayer(),
         defsNode = query$1('defs', canvas._svg);
17048
     var contents = innerSVG(contentNode),
         defs = defsNode ? '<defs>' + innerSVG(defsNode) + '</defs>' : '';
17051
     var bbox = contentNode.getBBox();
17053
     svg =
       '<?xml version="1.0" encoding="utf-8"?>\n' +
       '<!-- created with bpmn-js / http://bpmn.io -->\n' +
       '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n' +
       '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" ' +
            'width="' + bbox.width + '" height="' + bbox.height + '" ' +
            'viewBox="' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '" version="1.1">' +
         defs + contents +
       '</svg>';
   } catch (e) {
     err = e;
   }
17066
   self._emit('saveSVG.done', {
     error: err,
     svg: svg
   });
17071
   if (!err) {
     return resolve({ svg: svg });
   }
17075
   return reject(err);
 });
});
17079
/**
* Get a named diagram service.
*
* @example
*
* var elementRegistry = viewer.get('elementRegistry');
* var startEventShape = elementRegistry.get('StartEvent_1');
*
* @param {string} name
*
* @return {Object} diagram service instance
*
* @method BaseViewer#get
*/
17094
/**
* Invoke a function in the context of this viewer.
*
* @example
*
* viewer.invoke(function(elementRegistry) {
*   var startEventShape = elementRegistry.get('StartEvent_1');
* });
*
* @param {Function} fn to be invoked
*
* @return {Object} the functions return value
*
* @method BaseViewer#invoke
*/
17110
17111
BaseViewer.prototype._setDefinitions = function(definitions) {
 this._definitions = definitions;
};
17115
BaseViewer.prototype.getModules = function() {
 return this._modules;
};
17119
/**
* Remove all drawn elements from the viewer.
*
* After calling this method the viewer can still
* be reused for opening another diagram.
*
* @method BaseViewer#clear
*/
BaseViewer.prototype.clear = function() {
 if (!this.getDefinitions()) {
17130
   // no diagram to clear
   return;
 }
17134
 // remove drawn elements
 Diagram.prototype.clear.call(this);
};
17138
/**
* Destroy the viewer instance and remove all its
* remainders from the document tree.
*/
BaseViewer.prototype.destroy = function() {
17144
 // diagram destroy
 Diagram.prototype.destroy.call(this);
17147
 // dom detach
 remove$3(this._container);
};
17151
/**
* Register an event listener
*
* Remove a previously added listener via {@link #off(event, callback)}.
*
* @param {string} event
* @param {number} [priority]
* @param {Function} callback
* @param {Object} [that]
*/
BaseViewer.prototype.on = function(event, priority, callback, target) {
 return this.get('eventBus').on(event, priority, callback, target);
};
17165
/**
* De-register an event listener
*
* @param {string} event
* @param {Function} callback
*/
BaseViewer.prototype.off = function(event, callback) {
 this.get('eventBus').off(event, callback);
};
17175
BaseViewer.prototype.attachTo = function(parentNode) {
17177
 if (!parentNode) {
   throw new Error('parentNode required');
 }
17181
 // ensure we detach from the
 // previous, old parent
 this.detach();
17185
 // unwrap jQuery if provided
 if (parentNode.get && parentNode.constructor.prototype.jquery) {
   parentNode = parentNode.get(0);
 }
17190
 if (typeof parentNode === 'string') {
   parentNode = query$1(parentNode);
 }
17194
 parentNode.appendChild(this._container);
17196
 this._emit('attach', {});
17198
 this.get('canvas').resized();
};
17201
BaseViewer.prototype.getDefinitions = function() {
 return this._definitions;
};
17205
BaseViewer.prototype.detach = function() {
17207
 var container = this._container,
     parentNode = container.parentNode;
17210
 if (!parentNode) {
   return;
 }
17214
 this._emit('detach', {});
17216
 parentNode.removeChild(container);
};
17219
BaseViewer.prototype._init = function(container, moddle, options) {
17221
 var baseModules = options.modules || this.getModules(),
     additionalModules = options.additionalModules || [],
     staticModules = [
       {
         bpmnjs: [ 'value', this ],
         moddle: [ 'value', moddle ]
       }
     ];
17230
 var diagramModules = [].concat(staticModules, baseModules, additionalModules);
17232
 var diagramOptions = assign(omit(options, [ 'additionalModules' ]), {
   canvas: assign({}, options.canvas, { container: container }),
   modules: diagramModules
 });
17237
 // invoke diagram constructor
 Diagram.call(this, diagramOptions);
17240
 if (options && options.container) {
   this.attachTo(options.container);
 }
};
17245
/**
* Emit an event on the underlying {@link EventBus}
*
* @param  {string} type
* @param  {Object} event
*
* @return {Object} event processing result (if any)
*/
BaseViewer.prototype._emit = function(type, event) {
 return this.get('eventBus').fire(type, event);
};
17257
BaseViewer.prototype._createContainer = function(options) {
17259
 var container = domify$1('<div class="bjs-container"></div>');
17261
 assign$1$1(container, {
   width: ensureUnit(options.width),
   height: ensureUnit(options.height),
   position: options.position
 });
17267
 return container;
};
17270
BaseViewer.prototype._createModdle = function(options) {
 var moddleOptions = assign({}, this._moddleExtensions, options.moddleExtensions);
17273
 return new simple(moddleOptions);
};
17276
BaseViewer.prototype._modules = [];
17278
// helpers ///////////////
17280
function addWarningsToError(err, warningsAry) {
 err.warnings = warningsAry;
 return err;
}
17285
function checkValidationError(err) {
17287
 // check if we can help the user by indicating wrong BPMN 2.0 xml
 // (in case he or the exporting tool did not get that right)
17290
 var pattern = /unparsable content <([^>]+)> detected([\s\S]*)$/;
 var match = pattern.exec(err.message);
17293
 if (match) {
   err.message =
     'unparsable content <' + match[1] + '> detected; ' +
     'this may indicate an invalid BPMN 2.0 diagram file' + match[2];
 }
17299
 return err;
}
17302
var DEFAULT_OPTIONS = {
 width: '100%',
 height: '100%',
 position: 'relative'
};
17308
17309
/**
* Ensure the passed argument is a proper unit (defaulting to px)
*/
function ensureUnit(val) {
 return val + (isNumber(val) ? 'px' : '');
}
17316
17317
/**
* Find BPMNDiagram in definitions by ID
*
* @param {ModdleElement<Definitions>} definitions
* @param {string} diagramId
*
* @return {ModdleElement<BPMNDiagram>|null}
*/
function findBPMNDiagram(definitions, diagramId) {
 if (!diagramId) {
   return null;
 }
17330
 return find(definitions.diagrams, function(element) {
   return element.id === diagramId;
 }) || null;
}
17335
/**
* Adds the project logo to the diagram container as
* required by the bpmn.io license.
*
* @see http://bpmn.io/license
*
* @param {Element} container
*/
function addProjectLogo(container) {
 var img = BPMNIO_IMG;
17346
 var linkMarkup =
   '<a href="http://bpmn.io" ' +
      'target="_blank" ' +
      'class="bjs-powered-by" ' +
      'title="Powered by bpmn.io" ' +
     '>' +
     img +
   '</a>';
17355
 var linkElement = domify$1(linkMarkup);
17357
 assign$1$1(query$1('svg', linkElement), LOGO_STYLES);
 assign$1$1(linkElement, LINK_STYLES, {
   position: 'absolute',
   bottom: '15px',
   right: '15px',
   zIndex: '100'
 });
17365
 container.appendChild(linkElement);
17367
 componentEvent$1.bind(linkElement, 'click', function(event) {
   open();
17370
   event.preventDefault();
 });
}
17374
/* </project-logo> */
17376
/**
* A base modeler for BPMN 2.0 diagrams.
*
* Have a look at {@link Modeler} for a bundle that includes actual features.
*
* @param {Object} [options] configuration options to pass to the viewer
* @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.
* @param {string|number} [options.width] the width of the viewer
* @param {string|number} [options.height] the height of the viewer
* @param {Object} [options.moddleExtensions] extension packages to provide
* @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules
* @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules
*/
function BaseModeler(options) {
 BaseViewer.call(this, options);
17392
 // hook ID collection into the modeler
 this.on('import.parse.complete', function(event) {
   if (!event.error) {
     this._collectIds(event.definitions, event.elementsById);
   }
 }, this);
17399
 this.on('diagram.destroy', function() {
   this.get('moddle').ids.clear();
 }, this);
}
17404
inherits$1(BaseModeler, BaseViewer);
17406
17407
/**
* Create a moddle instance, attaching ids to it.
*
* @param {Object} options
*/
BaseModeler.prototype._createModdle = function(options) {
 var moddle = BaseViewer.prototype._createModdle.call(this, options);
17415
 // attach ids to moddle to be able to track
 // and validated ids in the BPMN 2.0 XML document
 // tree
 moddle.ids = new Ids([ 32, 36, 1 ]);
17420
 return moddle;
};
17423
/**
* Collect ids processed during parsing of the
* definitions object.
*
* @param {ModdleElement} definitions
* @param {Context} context
*/
BaseModeler.prototype._collectIds = function(definitions, elementsById) {
17432
 var moddle = definitions.$model,
     ids = moddle.ids,
     id;
17436
 // remove references from previous import
 ids.clear();
17439
 for (id in elementsById) {
   ids.claim(id, elementsById[id]);
 }
};
17444
function isExpanded(element, di) {
17446
 if (is$1(element, 'bpmn:CallActivity')) {
   return false;
 }
17450
 if (is$1(element, 'bpmn:SubProcess')) {
   di = di || getDi(element);
17453
   if (di && is$1(di, 'bpmndi:BPMNPlane')) {
     return true;
   }
17457
   return di && !!di.isExpanded;
 }
17460
 if (is$1(element, 'bpmn:Participant')) {
   return !!getBusinessObject(element).processRef;
 }
17464
 return true;
}
17467
function isInterrupting(element) {
 return element && getBusinessObject(element).isInterrupting !== false;
}
17471
function isEventSubProcess(element) {
 return element && !!getBusinessObject(element).triggeredByEvent;
}
17475
function hasEventDefinition$2(element, eventType) {
 var bo = getBusinessObject(element),
     hasEventDefinition = false;
17479
 if (bo.eventDefinitions) {
   forEach$2(bo.eventDefinitions, function(event) {
     if (is$1(event, eventType)) {
       hasEventDefinition = true;
     }
   });
 }
17487
 return hasEventDefinition;
}
17490
function hasErrorEventDefinition(element) {
 return hasEventDefinition$2(element, 'bpmn:ErrorEventDefinition');
}
17494
function hasEscalationEventDefinition(element) {
 return hasEventDefinition$2(element, 'bpmn:EscalationEventDefinition');
}
17498
function hasCompensateEventDefinition(element) {
 return hasEventDefinition$2(element, 'bpmn:CompensateEventDefinition');
}
17502
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';
 }
17515
 if (is$1(semantic, 'bpmn:TextAnnotation')) {
   return 'text';
 }
17519
 if (is$1(semantic, 'bpmn:Group')) {
   return 'categoryValueRef';
 }
}
17524
function getCategoryValue(semantic) {
 var categoryValueRef = semantic['categoryValueRef'];
17527
 if (!categoryValueRef) {
   return '';
 }
17531
17532
 return categoryValueRef.value || '';
}
17535
function getLabel(element) {
 var semantic = element.businessObject,
     attr = getLabelAttr(semantic);
17539
 if (attr) {
17541
   if (attr === 'categoryValueRef') {
17543
     return getCategoryValue(semantic);
   }
17546
   return semantic[attr] || '';
 }
}
17550
17551
function setLabel(element, text, isExternal) {
 var semantic = element.businessObject,
     attr = getLabelAttr(semantic);
17555
 if (attr) {
17557
   if (attr === 'categoryValueRef') {
     semantic['categoryValueRef'].value = text;
   } else {
     semantic[attr] = text;
   }
17563
 }
17565
 return element;
}
17568
// element utils //////////////////////
17570
/**
* Checks if eventDefinition of the given element matches with semantic type.
*
* @return {boolean} true if element is of the given semantic type
*/
function isTypedEvent(event, eventDefinitionType, filter) {
17577
 function matches(definition, filter) {
   return every(filter, function(val, key) {
17580
     // we want a == conversion here, to be able to catch
     // undefined == false and friends
     /* jshint -W116 */
     return definition[key] == val;
   });
 }
17587
 return some(event.eventDefinitions, function(definition) {
   return definition.$type === eventDefinitionType && matches(event, filter);
 });
}
17592
function isThrowEvent(event) {
 return (event.$type === 'bpmn:IntermediateThrowEvent') || (event.$type === 'bpmn:EndEvent');
}
17596
function isCollection(element) {
 var dataObject = element.dataObjectRef;
17599
 return element.isCollection || (dataObject && dataObject.isCollection);
}
17602
function getSemantic(element) {
 return element.businessObject;
}
17606
17607
// color access //////////////////////
17609
function getFillColor(element, defaultColor) {
 var di = getDi(element);
17612
 return di.get('color:background-color') || di.get('bioc:fill') || defaultColor || 'white';
}
17615
function getStrokeColor$1(element, defaultColor) {
 var di = getDi(element);
17618
 return di.get('color:border-color') || di.get('bioc:stroke') || defaultColor || 'black';
}
17621
function getLabelColor(element, defaultColor, defaultStrokeColor) {
 var di = getDi(element),
     label = di.get('label');
17625
 return label && label.get('color:color') || defaultColor ||
   getStrokeColor$1(element, defaultStrokeColor);
}
17629
// cropping path customizations //////////////////////
17631
function getCirclePath(shape) {
17633
 var cx = shape.x + shape.width / 2,
     cy = shape.y + shape.height / 2,
     radius = shape.width / 2;
17637
 var circlePath = [
   ['M', cx, cy],
   ['m', 0, -radius],
   ['a', radius, radius, 0, 1, 1, 0, 2 * radius],
   ['a', radius, radius, 0, 1, 1, 0, -2 * radius],
   ['z']
 ];
17645
 return componentsToPath(circlePath);
}
17648
function getRoundRectPath(shape, borderRadius) {
17650
 var x = shape.x,
     y = shape.y,
     width = shape.width,
     height = shape.height;
17655
 var roundRectPath = [
   ['M', x + borderRadius, y],
   ['l', width - borderRadius * 2, 0],
   ['a', borderRadius, borderRadius, 0, 0, 1, borderRadius, borderRadius],
   ['l', 0, height - borderRadius * 2],
   ['a', borderRadius, borderRadius, 0, 0, 1, -borderRadius, borderRadius],
   ['l', borderRadius * 2 - width, 0],
   ['a', borderRadius, borderRadius, 0, 0, 1, -borderRadius, -borderRadius],
   ['l', 0, borderRadius * 2 - height],
   ['a', borderRadius, borderRadius, 0, 0, 1, borderRadius, -borderRadius],
   ['z']
 ];
17668
 return componentsToPath(roundRectPath);
}
17671
function getDiamondPath(shape) {
17673
 var width = shape.width,
     height = shape.height,
     x = shape.x,
     y = shape.y,
     halfWidth = width / 2,
     halfHeight = height / 2;
17680
 var diamondPath = [
   ['M', x + halfWidth, y],
   ['l', halfWidth, halfHeight],
   ['l', -halfWidth, halfHeight],
   ['l', -halfWidth, -halfHeight],
   ['z']
 ];
17688
 return componentsToPath(diamondPath);
}
17691
function getRectPath(shape) {
 var x = shape.x,
     y = shape.y,
     width = shape.width,
     height = shape.height;
17697
 var rectPath = [
   ['M', x, y],
   ['l', width, 0],
   ['l', 0, height],
   ['l', -width, 0],
   ['z']
 ];
17705
 return componentsToPath(rectPath);
}
17708
var RENDERER_IDS = new Ids();
17710
var TASK_BORDER_RADIUS = 10;
var INNER_OUTER_DIST = 3;
17713
var DEFAULT_FILL_OPACITY = .95,
   HIGH_FILL_OPACITY = .35;
17716
var ELEMENT_LABEL_DISTANCE$1 = 10;
17718
function BpmnRenderer(
   config, eventBus, styles, pathMap,
   canvas, textRenderer, priority) {
17722
 BaseRenderer.call(this, eventBus, priority);
17724
 var defaultFillColor = config && config.defaultFillColor,
     defaultStrokeColor = config && config.defaultStrokeColor,
     defaultLabelColor = config && config.defaultLabelColor;
17728
 var rendererId = RENDERER_IDS.next();
17730
 var markers = {};
17732
 var computeStyle = styles.computeStyle;
17734
 function addMarker(id, options) {
   var attrs = assign({
     fill: 'black',
     strokeWidth: 1,
     strokeLinecap: 'round',
     strokeDasharray: 'none'
   }, options.attrs);
17742
   var ref = options.ref || { x: 0, y: 0 };
17744
   var scale = options.scale || 1;
17746
   // fix for safari / chrome / firefox bug not correctly
   // resetting stroke dash array
   if (attrs.strokeDasharray === 'none') {
     attrs.strokeDasharray = [10000, 1];
   }
17752
   var marker = create$1('marker');
17754
   attr$1(options.element, attrs);
17756
   append(marker, options.element);
17758
   attr$1(marker, {
     id: id,
     viewBox: '0 0 20 20',
     refX: ref.x,
     refY: ref.y,
     markerWidth: 20 * scale,
     markerHeight: 20 * scale,
     orient: 'auto'
   });
17768
   var defs = query$1('defs', canvas._svg);
17770
   if (!defs) {
     defs = create$1('defs');
17773
     append(canvas._svg, defs);
   }
17776
   append(defs, marker);
17778
   markers[id] = marker;
 }
17781
 function colorEscape(str) {
17783
   // only allow characters and numbers
   return str.replace(/[^0-9a-zA-z]+/g, '_');
 }
17787
 function marker(type, fill, stroke) {
   var id = type + '-' + colorEscape(fill) + '-' + colorEscape(stroke) + '-' + rendererId;
17790
   if (!markers[id]) {
     createMarker(id, type, fill, stroke);
   }
17794
   return 'url(#' + id + ')';
 }
17797
 function createMarker(id, type, fill, stroke) {
17799
   if (type === 'sequenceflow-end') {
     var sequenceflowEnd = create$1('path');
     attr$1(sequenceflowEnd, { d: 'M 1 5 L 11 10 L 1 15 Z' });
17803
     addMarker(id, {
       element: sequenceflowEnd,
       ref: { x: 11, y: 10 },
       scale: 0.5,
       attrs: {
         fill: stroke,
         stroke: stroke
       }
     });
   }
17814
   if (type === 'messageflow-start') {
     var messageflowStart = create$1('circle');
     attr$1(messageflowStart, { cx: 6, cy: 6, r: 3.5 });
17818
     addMarker(id, {
       element: messageflowStart,
       attrs: {
         fill: fill,
         stroke: stroke
       },
       ref: { x: 6, y: 6 }
     });
   }
17828
   if (type === 'messageflow-end') {
     var messageflowEnd = create$1('path');
     attr$1(messageflowEnd, { d: 'm 1 5 l 0 -3 l 7 3 l -7 3 z' });
17832
     addMarker(id, {
       element: messageflowEnd,
       attrs: {
         fill: fill,
         stroke: stroke,
         strokeLinecap: 'butt'
       },
       ref: { x: 8.5, y: 5 }
     });
   }
17843
   if (type === 'association-start') {
     var associationStart = create$1('path');
     attr$1(associationStart, { d: 'M 11 5 L 1 10 L 11 15' });
17847
     addMarker(id, {
       element: associationStart,
       attrs: {
         fill: 'none',
         stroke: stroke,
         strokeWidth: 1.5
       },
       ref: { x: 1, y: 10 },
       scale: 0.5
     });
   }
17859
   if (type === 'association-end') {
     var associationEnd = create$1('path');
     attr$1(associationEnd, { d: 'M 1 5 L 11 10 L 1 15' });
17863
     addMarker(id, {
       element: associationEnd,
       attrs: {
         fill: 'none',
         stroke: stroke,
         strokeWidth: 1.5
       },
       ref: { x: 12, y: 10 },
       scale: 0.5
     });
   }
17875
   if (type === 'conditional-flow-marker') {
     var conditionalflowMarker = create$1('path');
     attr$1(conditionalflowMarker, { d: 'M 0 10 L 8 6 L 16 10 L 8 14 Z' });
17879
     addMarker(id, {
       element: conditionalflowMarker,
       attrs: {
         fill: fill,
         stroke: stroke
       },
       ref: { x: -1, y: 10 },
       scale: 0.5
     });
   }
17890
   if (type === 'conditional-default-flow-marker') {
     var conditionaldefaultflowMarker = create$1('path');
     attr$1(conditionaldefaultflowMarker, { d: 'M 6 4 L 10 16' });
17894
     addMarker(id, {
       element: conditionaldefaultflowMarker,
       attrs: {
         stroke: stroke
       },
       ref: { x: 0, y: 10 },
       scale: 0.5
     });
   }
 }
17905
 function drawCircle(parentGfx, width, height, offset, attrs) {
17907
   if (isObject(offset)) {
     attrs = offset;
     offset = 0;
   }
17912
   offset = offset || 0;
17914
   attrs = computeStyle(attrs, {
     stroke: 'black',
     strokeWidth: 2,
     fill: 'white'
   });
17920
   if (attrs.fill === 'none') {
     delete attrs.fillOpacity;
   }
17924
   var cx = width / 2,
       cy = height / 2;
17927
   var circle = create$1('circle');
   attr$1(circle, {
     cx: cx,
     cy: cy,
     r: Math.round((width + height) / 4 - offset)
   });
   attr$1(circle, attrs);
17935
   append(parentGfx, circle);
17937
   return circle;
 }
17940
 function drawRect(parentGfx, width, height, r, offset, attrs) {
17942
   if (isObject(offset)) {
     attrs = offset;
     offset = 0;
   }
17947
   offset = offset || 0;
17949
   attrs = computeStyle(attrs, {
     stroke: 'black',
     strokeWidth: 2,
     fill: 'white'
   });
17955
   var rect = create$1('rect');
   attr$1(rect, {
     x: offset,
     y: offset,
     width: width - offset * 2,
     height: height - offset * 2,
     rx: r,
     ry: r
   });
   attr$1(rect, attrs);
17966
   append(parentGfx, rect);
17968
   return rect;
 }
17971
 function drawDiamond(parentGfx, width, height, attrs) {
17973
   var x_2 = width / 2;
   var y_2 = height / 2;
17976
   var points = [{ x: x_2, y: 0 }, { x: width, y: y_2 }, { x: x_2, y: height }, { x: 0, y: y_2 }];
17978
   var pointsString = points.map(function(point) {
     return point.x + ',' + point.y;
   }).join(' ');
17982
   attrs = computeStyle(attrs, {
     stroke: 'black',
     strokeWidth: 2,
     fill: 'white'
   });
17988
   var polygon = create$1('polygon');
   attr$1(polygon, {
     points: pointsString
   });
   attr$1(polygon, attrs);
17994
   append(parentGfx, polygon);
17996
   return polygon;
 }
17999
 function drawLine(parentGfx, waypoints, attrs) {
   attrs = computeStyle(attrs, [ 'no-fill' ], {
     stroke: 'black',
     strokeWidth: 2,
     fill: 'none'
   });
18006
   var line = createLine(waypoints, attrs);
18008
   append(parentGfx, line);
18010
   return line;
 }
18013
 function drawPath(parentGfx, d, attrs) {
18015
   attrs = computeStyle(attrs, [ 'no-fill' ], {
     strokeWidth: 2,
     stroke: 'black'
   });
18020
   var path = create$1('path');
   attr$1(path, { d: d });
   attr$1(path, attrs);
18024
   append(parentGfx, path);
18026
   return path;
 }
18029
 function drawMarker(type, parentGfx, path, attrs) {
   return drawPath(parentGfx, path, assign({ 'data-marker': type }, attrs));
 }
18033
 function renderer(type) {
   return handlers[type];
 }
18037
 function as(type) {
   return function(parentGfx, element) {
     return renderer(type)(parentGfx, element);
   };
 }
18043
 function renderEventContent(element, parentGfx) {
18045
   var event = getSemantic(element);
   var isThrowing = isThrowEvent(event);
18048
   if (event.eventDefinitions && event.eventDefinitions.length>1) {
     if (event.parallelMultiple) {
       return renderer('bpmn:ParallelMultipleEventDefinition')(parentGfx, element, isThrowing);
     }
     else {
       return renderer('bpmn:MultipleEventDefinition')(parentGfx, element, isThrowing);
     }
   }
18057
   if (isTypedEvent(event, 'bpmn:MessageEventDefinition')) {
     return renderer('bpmn:MessageEventDefinition')(parentGfx, element, isThrowing);
   }
18061
   if (isTypedEvent(event, 'bpmn:TimerEventDefinition')) {
     return renderer('bpmn:TimerEventDefinition')(parentGfx, element, isThrowing);
   }
18065
   if (isTypedEvent(event, 'bpmn:ConditionalEventDefinition')) {
     return renderer('bpmn:ConditionalEventDefinition')(parentGfx, element);
   }
18069
   if (isTypedEvent(event, 'bpmn:SignalEventDefinition')) {
     return renderer('bpmn:SignalEventDefinition')(parentGfx, element, isThrowing);
   }
18073
   if (isTypedEvent(event, 'bpmn:EscalationEventDefinition')) {
     return renderer('bpmn:EscalationEventDefinition')(parentGfx, element, isThrowing);
   }
18077
   if (isTypedEvent(event, 'bpmn:LinkEventDefinition')) {
     return renderer('bpmn:LinkEventDefinition')(parentGfx, element, isThrowing);
   }
18081
   if (isTypedEvent(event, 'bpmn:ErrorEventDefinition')) {
     return renderer('bpmn:ErrorEventDefinition')(parentGfx, element, isThrowing);
   }
18085
   if (isTypedEvent(event, 'bpmn:CancelEventDefinition')) {
     return renderer('bpmn:CancelEventDefinition')(parentGfx, element, isThrowing);
   }
18089
   if (isTypedEvent(event, 'bpmn:CompensateEventDefinition')) {
     return renderer('bpmn:CompensateEventDefinition')(parentGfx, element, isThrowing);
   }
18093
   if (isTypedEvent(event, 'bpmn:TerminateEventDefinition')) {
     return renderer('bpmn:TerminateEventDefinition')(parentGfx, element, isThrowing);
   }
18097
   return null;
 }
18100
 function renderLabel(parentGfx, label, options) {
18102
   options = assign({
     size: {
       width: 100
     }
   }, options);
18108
   var text = textRenderer.createText(label || '', options);
18110
   classes$1(text).add('djs-label');
18112
   append(parentGfx, text);
18114
   return text;
 }
18117
 function renderEmbeddedLabel(parentGfx, element, align) {
   var semantic = getSemantic(element);
18120
   return renderLabel(parentGfx, semantic.name, {
     box: element,
     align: align,
     padding: 5,
     style: {
       fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
     }
   });
 }
18130
 function renderExternalLabel(parentGfx, element) {
18132
   var box = {
     width: 90,
     height: 30,
     x: element.width / 2 + element.x,
     y: element.height / 2 + element.y
   };
18139
   return renderLabel(parentGfx, getLabel(element), {
     box: box,
     fitBox: true,
     style: assign(
       {},
       textRenderer.getExternalStyle(),
       {
         fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
       }
     )
   });
 }
18152
 function renderLaneLabel(parentGfx, text, element) {
   var textBox = renderLabel(parentGfx, text, {
     box: {
       height: 30,
       width: element.height
     },
     align: 'center-middle',
     style: {
       fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
     }
   });
18164
   var top = -1 * element.height;
18166
   transform(textBox, 0, -top, 270);
 }
18169
 function createPathFromConnection(connection) {
   var waypoints = connection.waypoints;
18172
   var pathData = 'm  ' + waypoints[0].x + ',' + waypoints[0].y;
   for (var i = 1; i < waypoints.length; i++) {
     pathData += 'L' + waypoints[i].x + ',' + waypoints[i].y + ' ';
   }
   return pathData;
 }
18179
 var handlers = this.handlers = {
   'bpmn:Event': function(parentGfx, element, attrs) {
18182
     if (!('fillOpacity' in attrs)) {
       attrs.fillOpacity = DEFAULT_FILL_OPACITY;
     }
18186
     return drawCircle(parentGfx, element.width, element.height, attrs);
   },
   'bpmn:StartEvent': function(parentGfx, element) {
     var attrs = {
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
18194
     var semantic = getSemantic(element);
18196
     if (!semantic.isInterrupting) {
       attrs = {
         strokeDasharray: '6',
         strokeLinecap: 'round',
         fill: getFillColor(element, defaultFillColor),
         stroke: getStrokeColor$1(element, defaultStrokeColor)
       };
     }
18205
     var circle = renderer('bpmn:Event')(parentGfx, element, attrs);
18207
     renderEventContent(element, parentGfx);
18209
     return circle;
   },
   'bpmn:MessageEventDefinition': function(parentGfx, element, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_MESSAGE', {
       xScaleFactor: 0.9,
       yScaleFactor: 0.9,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.235,
         my: 0.315
       }
     });
18223
     var fill = isThrowing ? getStrokeColor$1(element, defaultStrokeColor) : getFillColor(element, defaultFillColor);
     var stroke = isThrowing ? getFillColor(element, defaultFillColor) : getStrokeColor$1(element, defaultStrokeColor);
18226
     var messagePath = drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: stroke
     });
18232
     return messagePath;
   },
   'bpmn:TimerEventDefinition': function(parentGfx, element) {
     var circle = drawCircle(parentGfx, element.width, element.height, 0.2 * element.height, {
       strokeWidth: 2,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18241
     var pathData = pathMap.getScaledPath('EVENT_TIMER_WH', {
       xScaleFactor: 0.75,
       yScaleFactor: 0.75,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.5,
         my: 0.5
       }
     });
18252
     drawPath(parentGfx, pathData, {
       strokeWidth: 2,
       strokeLinecap: 'square',
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18258
     for (var i = 0;i < 12; i++) {
18260
       var linePathData = pathMap.getScaledPath('EVENT_TIMER_LINE', {
         xScaleFactor: 0.75,
         yScaleFactor: 0.75,
         containerWidth: element.width,
         containerHeight: element.height,
         position: {
           mx: 0.5,
           my: 0.5
         }
       });
18271
       var width = element.width / 2;
       var height = element.height / 2;
18274
       drawPath(parentGfx, linePathData, {
         strokeWidth: 1,
         strokeLinecap: 'square',
         transform: 'rotate(' + (i * 30) + ',' + height + ',' + width + ')',
         stroke: getStrokeColor$1(element, defaultStrokeColor)
       });
     }
18282
     return circle;
   },
   'bpmn:EscalationEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_ESCALATION', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.5,
         my: 0.2
       }
     });
18296
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18298
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:ConditionalEventDefinition': function(parentGfx, event) {
     var pathData = pathMap.getScaledPath('EVENT_CONDITIONAL', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.5,
         my: 0.222
       }
     });
18316
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:LinkEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_LINK', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.57,
         my: 0.263
       }
     });
18333
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18335
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:ErrorEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_ERROR', {
       xScaleFactor: 1.1,
       yScaleFactor: 1.1,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.2,
         my: 0.722
       }
     });
18353
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18355
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:CancelEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_CANCEL_45', {
       xScaleFactor: 1.0,
       yScaleFactor: 1.0,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.638,
         my: -0.055
       }
     });
18373
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18375
     var path = drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
18381
     rotate(path, 45);
18383
     return path;
   },
   'bpmn:CompensateEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_COMPENSATION', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.22,
         my: 0.5
       }
     });
18397
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18399
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:SignalEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_SIGNAL', {
       xScaleFactor: 0.9,
       yScaleFactor: 0.9,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.5,
         my: 0.2
       }
     });
18417
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18419
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill,
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:MultipleEventDefinition': function(parentGfx, event, isThrowing) {
     var pathData = pathMap.getScaledPath('EVENT_MULTIPLE', {
       xScaleFactor: 1.1,
       yScaleFactor: 1.1,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.222,
         my: 0.36
       }
     });
18437
     var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
18439
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: fill
     });
   },
   'bpmn:ParallelMultipleEventDefinition': function(parentGfx, event) {
     var pathData = pathMap.getScaledPath('EVENT_PARALLEL_MULTIPLE', {
       xScaleFactor: 1.2,
       yScaleFactor: 1.2,
       containerWidth: event.width,
       containerHeight: event.height,
       position: {
         mx: 0.458,
         my: 0.194
       }
     });
18456
     return drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: getStrokeColor$1(event, defaultStrokeColor),
       stroke: getStrokeColor$1(event, defaultStrokeColor)
     });
   },
   'bpmn:EndEvent': function(parentGfx, element) {
     var circle = renderer('bpmn:Event')(parentGfx, element, {
       strokeWidth: 4,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18469
     renderEventContent(element, parentGfx);
18471
     return circle;
   },
   'bpmn:TerminateEventDefinition': function(parentGfx, element) {
     var circle = drawCircle(parentGfx, element.width, element.height, 8, {
       strokeWidth: 4,
       fill: getStrokeColor$1(element, defaultStrokeColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18480
     return circle;
   },
   'bpmn:IntermediateEvent': function(parentGfx, element) {
     var outer = renderer('bpmn:Event')(parentGfx, element, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18489
     /* inner */
     drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, {
       strokeWidth: 1,
       fill: getFillColor(element, 'none'),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18496
     renderEventContent(element, parentGfx);
18498
     return outer;
   },
   'bpmn:IntermediateCatchEvent': as('bpmn:IntermediateEvent'),
   'bpmn:IntermediateThrowEvent': as('bpmn:IntermediateEvent'),
18503
   'bpmn:Activity': function(parentGfx, element, attrs) {
18505
     attrs = attrs || {};
18507
     if (!('fillOpacity' in attrs)) {
       attrs.fillOpacity = DEFAULT_FILL_OPACITY;
     }
18511
     return drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, attrs);
   },
18514
   'bpmn:Task': function(parentGfx, element) {
     var attrs = {
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
18520
     var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);
18522
     renderEmbeddedLabel(parentGfx, element, 'center-middle');
     attachTaskMarkers(parentGfx, element);
18525
     return rect;
   },
   'bpmn:ServiceTask': function(parentGfx, element) {
     var task = renderer('bpmn:Task')(parentGfx, element);
18530
     var pathDataBG = pathMap.getScaledPath('TASK_TYPE_SERVICE', {
       abspos: {
         x: 12,
         y: 18
       }
     });
18537
     /* service bg */ drawPath(parentGfx, pathDataBG, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18543
     var fillPathData = pathMap.getScaledPath('TASK_TYPE_SERVICE_FILL', {
       abspos: {
         x: 17.2,
         y: 18
       }
     });
18550
     /* service fill */ drawPath(parentGfx, fillPathData, {
       strokeWidth: 0,
       fill: getFillColor(element, defaultFillColor)
     });
18555
     var pathData = pathMap.getScaledPath('TASK_TYPE_SERVICE', {
       abspos: {
         x: 17,
         y: 22
       }
     });
18562
     /* service */ drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18568
     return task;
   },
   'bpmn:UserTask': function(parentGfx, element) {
     var task = renderer('bpmn:Task')(parentGfx, element);
18573
     var x = 15;
     var y = 12;
18576
     var pathData = pathMap.getScaledPath('TASK_TYPE_USER_1', {
       abspos: {
         x: x,
         y: y
       }
     });
18583
     /* user path */ drawPath(parentGfx, pathData, {
       strokeWidth: 0.5,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18589
     var pathData2 = pathMap.getScaledPath('TASK_TYPE_USER_2', {
       abspos: {
         x: x,
         y: y
       }
     });
18596
     /* user2 path */ drawPath(parentGfx, pathData2, {
       strokeWidth: 0.5,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18602
     var pathData3 = pathMap.getScaledPath('TASK_TYPE_USER_3', {
       abspos: {
         x: x,
         y: y
       }
     });
18609
     /* user3 path */ drawPath(parentGfx, pathData3, {
       strokeWidth: 0.5,
       fill: getStrokeColor$1(element, defaultStrokeColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18615
     return task;
   },
   'bpmn:ManualTask': function(parentGfx, element) {
     var task = renderer('bpmn:Task')(parentGfx, element);
18620
     var pathData = pathMap.getScaledPath('TASK_TYPE_MANUAL', {
       abspos: {
         x: 17,
         y: 15
       }
     });
18627
     /* manual path */ drawPath(parentGfx, pathData, {
       strokeWidth: 0.5, // 0.25,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18633
     return task;
   },
   'bpmn:SendTask': function(parentGfx, element) {
     var task = renderer('bpmn:Task')(parentGfx, element);
18638
     var pathData = pathMap.getScaledPath('TASK_TYPE_SEND', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: 21,
       containerHeight: 14,
       position: {
         mx: 0.285,
         my: 0.357
       }
     });
18649
     /* send path */ drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: getStrokeColor$1(element, defaultStrokeColor),
       stroke: getFillColor(element, defaultFillColor)
     });
18655
     return task;
   },
   'bpmn:ReceiveTask' : function(parentGfx, element) {
     var semantic = getSemantic(element);
18660
     var task = renderer('bpmn:Task')(parentGfx, element);
     var pathData;
18663
     if (semantic.instantiate) {
       drawCircle(parentGfx, 28, 28, 20 * 0.22, { strokeWidth: 1 });
18666
       pathData = pathMap.getScaledPath('TASK_TYPE_INSTANTIATING_SEND', {
         abspos: {
           x: 7.77,
           y: 9.52
         }
       });
     } else {
18674
       pathData = pathMap.getScaledPath('TASK_TYPE_SEND', {
         xScaleFactor: 0.9,
         yScaleFactor: 0.9,
         containerWidth: 21,
         containerHeight: 14,
         position: {
           mx: 0.3,
           my: 0.4
         }
       });
     }
18686
     /* receive path */ drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18692
     return task;
   },
   'bpmn:ScriptTask': function(parentGfx, element) {
     var task = renderer('bpmn:Task')(parentGfx, element);
18697
     var pathData = pathMap.getScaledPath('TASK_TYPE_SCRIPT', {
       abspos: {
         x: 15,
         y: 20
       }
     });
18704
     /* script path */ drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18709
     return task;
   },
   'bpmn:BusinessRuleTask': function(parentGfx, element) {
     var task = renderer('bpmn:Task')(parentGfx, element);
18714
     var headerPathData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_HEADER', {
       abspos: {
         x: 8,
         y: 8
       }
     });
18721
     var businessHeaderPath = drawPath(parentGfx, headerPathData);
     attr$1(businessHeaderPath, {
       strokeWidth: 1,
       fill: getFillColor(element, '#aaaaaa'),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18728
     var headerData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_MAIN', {
       abspos: {
         x: 8,
         y: 8
       }
     });
18735
     var businessPath = drawPath(parentGfx, headerData);
     attr$1(businessPath, {
       strokeWidth: 1,
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18741
     return task;
   },
   'bpmn:SubProcess': function(parentGfx, element, attrs) {
     attrs = assign({
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     }, attrs);
18749
     var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);
18751
     var expanded = isExpanded(element);
18753
     if (isEventSubProcess(element)) {
       attr$1(rect, {
         strokeDasharray: '1,2'
       });
     }
18759
     renderEmbeddedLabel(parentGfx, element, expanded ? 'center-top' : 'center-middle');
18761
     if (expanded) {
       attachTaskMarkers(parentGfx, element);
     } else {
       attachTaskMarkers(parentGfx, element, ['SubProcessMarker']);
     }
18767
     return rect;
   },
   'bpmn:AdHocSubProcess': function(parentGfx, element) {
     return renderer('bpmn:SubProcess')(parentGfx, element);
   },
   'bpmn:Transaction': function(parentGfx, element) {
     var outer = renderer('bpmn:SubProcess')(parentGfx, element);
18775
     var innerAttrs = styles.style([ 'no-fill', 'no-events' ], {
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18779
     /* inner path */ drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS - 2, INNER_OUTER_DIST, innerAttrs);
18781
     return outer;
   },
   'bpmn:CallActivity': function(parentGfx, element) {
     return renderer('bpmn:SubProcess')(parentGfx, element, {
       strokeWidth: 5
     });
   },
   'bpmn:Participant': function(parentGfx, element) {
18790
     var attrs = {
       fillOpacity: DEFAULT_FILL_OPACITY,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
18796
     var lane = renderer('bpmn:Lane')(parentGfx, element, attrs);
18798
     var expandedPool = isExpanded(element);
18800
     if (expandedPool) {
       drawLine(parentGfx, [
         { x: 30, y: 0 },
         { x: 30, y: element.height }
       ], {
         stroke: getStrokeColor$1(element, defaultStrokeColor)
       });
       var text = getSemantic(element).name;
       renderLaneLabel(parentGfx, text, element);
     } else {
18811
       // Collapsed pool draw text inline
       var text2 = getSemantic(element).name;
       renderLabel(parentGfx, text2, {
         box: element, align: 'center-middle',
         style: {
           fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
         }
       });
     }
18821
     var participantMultiplicity = !!(getSemantic(element).participantMultiplicity);
18823
     if (participantMultiplicity) {
       renderer('ParticipantMultiplicityMarker')(parentGfx, element);
     }
18827
     return lane;
   },
   'bpmn:Lane': function(parentGfx, element, attrs) {
     var rect = drawRect(parentGfx, element.width, element.height, 0, assign({
       fill: getFillColor(element, defaultFillColor),
       fillOpacity: HIGH_FILL_OPACITY,
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     }, attrs));
18836
     var semantic = getSemantic(element);
18838
     if (semantic.$type === 'bpmn:Lane') {
       var text = semantic.name;
       renderLaneLabel(parentGfx, text, element);
     }
18843
     return rect;
   },
   'bpmn:InclusiveGateway': function(parentGfx, element) {
     var diamond = renderer('bpmn:Gateway')(parentGfx, element);
18848
     /* circle path */
     drawCircle(parentGfx, element.width, element.height, element.height * 0.24, {
       strokeWidth: 2.5,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18855
     return diamond;
   },
   'bpmn:ExclusiveGateway': function(parentGfx, element) {
     var diamond = renderer('bpmn:Gateway')(parentGfx, element);
18860
     var pathData = pathMap.getScaledPath('GATEWAY_EXCLUSIVE', {
       xScaleFactor: 0.4,
       yScaleFactor: 0.4,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.32,
         my: 0.3
       }
     });
18871
     if ((getDi(element).isMarkerVisible)) {
       drawPath(parentGfx, pathData, {
         strokeWidth: 1,
         fill: getStrokeColor$1(element, defaultStrokeColor),
         stroke: getStrokeColor$1(element, defaultStrokeColor)
       });
     }
18879
     return diamond;
   },
   'bpmn:ComplexGateway': function(parentGfx, element) {
     var diamond = renderer('bpmn:Gateway')(parentGfx, element);
18884
     var pathData = pathMap.getScaledPath('GATEWAY_COMPLEX', {
       xScaleFactor: 0.5,
       yScaleFactor:0.5,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.46,
         my: 0.26
       }
     });
18895
     /* complex path */ drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: getStrokeColor$1(element, defaultStrokeColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18901
     return diamond;
   },
   'bpmn:ParallelGateway': function(parentGfx, element) {
     var diamond = renderer('bpmn:Gateway')(parentGfx, element);
18906
     var pathData = pathMap.getScaledPath('GATEWAY_PARALLEL', {
       xScaleFactor: 0.6,
       yScaleFactor:0.6,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.46,
         my: 0.2
       }
     });
18917
     /* parallel path */ drawPath(parentGfx, pathData, {
       strokeWidth: 1,
       fill: getStrokeColor$1(element, defaultStrokeColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18923
     return diamond;
   },
   'bpmn:EventBasedGateway': function(parentGfx, element) {
18927
     var semantic = getSemantic(element);
18929
     var diamond = renderer('bpmn:Gateway')(parentGfx, element);
18931
     /* outer circle path */ drawCircle(parentGfx, element.width, element.height, element.height * 0.20, {
       strokeWidth: 1,
       fill: 'none',
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
18937
     var type = semantic.eventGatewayType;
     var instantiate = !!semantic.instantiate;
18940
     function drawEvent() {
18942
       var pathData = pathMap.getScaledPath('GATEWAY_EVENT_BASED', {
         xScaleFactor: 0.18,
         yScaleFactor: 0.18,
         containerWidth: element.width,
         containerHeight: element.height,
         position: {
           mx: 0.36,
           my: 0.44
         }
       });
18953
       var attrs = {
         strokeWidth: 2,
         fill: getFillColor(element, 'none'),
         stroke: getStrokeColor$1(element, defaultStrokeColor)
       };
18959
       /* event path */ drawPath(parentGfx, pathData, attrs);
     }
18962
     if (type === 'Parallel') {
18964
       var pathData = pathMap.getScaledPath('GATEWAY_PARALLEL', {
         xScaleFactor: 0.4,
         yScaleFactor:0.4,
         containerWidth: element.width,
         containerHeight: element.height,
         position: {
           mx: 0.474,
           my: 0.296
         }
       });
18975
       var parallelPath = drawPath(parentGfx, pathData);
       attr$1(parallelPath, {
         strokeWidth: 1,
         fill: 'none'
       });
     } else if (type === 'Exclusive') {
18982
       if (!instantiate) {
         var innerCircle = drawCircle(parentGfx, element.width, element.height, element.height * 0.26);
         attr$1(innerCircle, {
           strokeWidth: 1,
           fill: 'none',
           stroke: getStrokeColor$1(element, defaultStrokeColor)
         });
       }
18991
       drawEvent();
     }
18994
18995
     return diamond;
   },
   'bpmn:Gateway': function(parentGfx, element) {
     var attrs = {
       fill: getFillColor(element, defaultFillColor),
       fillOpacity: DEFAULT_FILL_OPACITY,
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
19004
     return drawDiamond(parentGfx, element.width, element.height, attrs);
   },
   'bpmn:SequenceFlow': function(parentGfx, element) {
     var pathData = createPathFromConnection(element);
19009
     var fill = getFillColor(element, defaultFillColor),
         stroke = getStrokeColor$1(element, defaultStrokeColor);
19012
     var attrs = {
       strokeLinejoin: 'round',
       markerEnd: marker('sequenceflow-end', fill, stroke),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
19018
     var path = drawPath(parentGfx, pathData, attrs);
19020
     var sequenceFlow = getSemantic(element);
19022
     var source;
19024
     if (element.source) {
       source = element.source.businessObject;
19027
       // conditional flow marker
       if (sequenceFlow.conditionExpression && source.$instanceOf('bpmn:Activity')) {
         attr$1(path, {
           markerStart: marker('conditional-flow-marker', fill, stroke)
         });
       }
19034
       // default marker
       if (source.default && (source.$instanceOf('bpmn:Gateway') || source.$instanceOf('bpmn:Activity')) &&
           source.default === sequenceFlow) {
         attr$1(path, {
           markerStart: marker('conditional-default-flow-marker', fill, stroke)
         });
       }
     }
19043
     return path;
   },
   'bpmn:Association': function(parentGfx, element, attrs) {
19047
     var semantic = getSemantic(element);
19049
     var fill = getFillColor(element, defaultFillColor),
         stroke = getStrokeColor$1(element, defaultStrokeColor);
19052
     attrs = assign({
       strokeDasharray: '0.5, 5',
       strokeLinecap: 'round',
       strokeLinejoin: 'round',
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     }, attrs || {});
19059
     if (semantic.associationDirection === 'One' ||
         semantic.associationDirection === 'Both') {
       attrs.markerEnd = marker('association-end', fill, stroke);
     }
19064
     if (semantic.associationDirection === 'Both') {
       attrs.markerStart = marker('association-start', fill, stroke);
     }
19068
     return drawLine(parentGfx, element.waypoints, attrs);
   },
   'bpmn:DataInputAssociation': function(parentGfx, element) {
     var fill = getFillColor(element, defaultFillColor),
         stroke = getStrokeColor$1(element, defaultStrokeColor);
19074
     return renderer('bpmn:Association')(parentGfx, element, {
       markerEnd: marker('association-end', fill, stroke)
     });
   },
   'bpmn:DataOutputAssociation': function(parentGfx, element) {
     var fill = getFillColor(element, defaultFillColor),
         stroke = getStrokeColor$1(element, defaultStrokeColor);
19082
     return renderer('bpmn:Association')(parentGfx, element, {
       markerEnd: marker('association-end', fill, stroke)
     });
   },
   'bpmn:MessageFlow': function(parentGfx, element) {
19088
     var semantic = getSemantic(element),
         di = getDi(element);
19091
     var fill = getFillColor(element, defaultFillColor),
         stroke = getStrokeColor$1(element, defaultStrokeColor);
19094
     var pathData = createPathFromConnection(element);
19096
     var attrs = {
       markerEnd: marker('messageflow-end', fill, stroke),
       markerStart: marker('messageflow-start', fill, stroke),
       strokeDasharray: '10, 12',
       strokeLinecap: 'round',
       strokeLinejoin: 'round',
       strokeWidth: '1.5px',
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
19106
     var path = drawPath(parentGfx, pathData, attrs);
19108
     if (semantic.messageRef) {
       var midPoint = path.getPointAtLength(path.getTotalLength() / 2);
19111
       var markerPathData = pathMap.getScaledPath('MESSAGE_FLOW_MARKER', {
         abspos: {
           x: midPoint.x,
           y: midPoint.y
         }
       });
19118
       var messageAttrs = { strokeWidth: 1 };
19120
       if (di.messageVisibleKind === 'initiating') {
         messageAttrs.fill = 'white';
         messageAttrs.stroke = 'black';
       } else {
         messageAttrs.fill = '#888';
         messageAttrs.stroke = 'white';
       }
19128
       var message = drawPath(parentGfx, markerPathData, messageAttrs);
19130
       var labelText = semantic.messageRef.name;
       var label = renderLabel(parentGfx, labelText, {
         align: 'center-top',
         fitBox: true,
         style: {
           fill: getStrokeColor$1(element, defaultLabelColor)
         }
       });
19139
       var messageBounds = message.getBBox(),
           labelBounds = label.getBBox();
19142
       var translateX = midPoint.x - labelBounds.width / 2,
           translateY = midPoint.y + messageBounds.height / 2 + ELEMENT_LABEL_DISTANCE$1;
19145
       transform(label, translateX, translateY, 0);
19147
     }
19149
     return path;
   },
   'bpmn:DataObject': function(parentGfx, element) {
     var pathData = pathMap.getScaledPath('DATA_OBJECT_PATH', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.474,
         my: 0.296
       }
     });
19163
     var elementObject = drawPath(parentGfx, pathData, {
       fill: getFillColor(element, defaultFillColor),
       fillOpacity: DEFAULT_FILL_OPACITY,
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
19169
     var semantic = getSemantic(element);
19171
     if (isCollection(semantic)) {
       renderDataItemCollection(parentGfx, element);
     }
19175
     return elementObject;
   },
   'bpmn:DataObjectReference': as('bpmn:DataObject'),
   'bpmn:DataInput': function(parentGfx, element) {
19180
     var arrowPathData = pathMap.getRawPath('DATA_ARROW');
19182
     // page
     var elementObject = renderer('bpmn:DataObject')(parentGfx, element);
19185
     /* input arrow path */ drawPath(parentGfx, arrowPathData, { strokeWidth: 1 });
19187
     return elementObject;
   },
   'bpmn:DataOutput': function(parentGfx, element) {
     var arrowPathData = pathMap.getRawPath('DATA_ARROW');
19192
     // page
     var elementObject = renderer('bpmn:DataObject')(parentGfx, element);
19195
     /* output arrow path */ drawPath(parentGfx, arrowPathData, {
       strokeWidth: 1,
       fill: 'black'
     });
19200
     return elementObject;
   },
   'bpmn:DataStoreReference': function(parentGfx, element) {
     var DATA_STORE_PATH = pathMap.getScaledPath('DATA_STORE', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0,
         my: 0.133
       }
     });
19214
     var elementStore = drawPath(parentGfx, DATA_STORE_PATH, {
       strokeWidth: 2,
       fill: getFillColor(element, defaultFillColor),
       fillOpacity: DEFAULT_FILL_OPACITY,
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
19221
     return elementStore;
   },
   'bpmn:BoundaryEvent': function(parentGfx, element) {
19225
     var semantic = getSemantic(element),
         cancel = semantic.cancelActivity;
19228
     var attrs = {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     };
19234
     if (!cancel) {
       attrs.strokeDasharray = '6';
       attrs.strokeLinecap = 'round';
     }
19239
     // apply fillOpacity
     var outerAttrs = assign({}, attrs, {
       fillOpacity: 1
     });
19244
     // apply no-fill
     var innerAttrs = assign({}, attrs, {
       fill: 'none'
     });
19249
     var outer = renderer('bpmn:Event')(parentGfx, element, outerAttrs);
19251
     /* inner path */ drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, innerAttrs);
19253
     renderEventContent(element, parentGfx);
19255
     return outer;
   },
   'bpmn:Group': function(parentGfx, element) {
19259
     var group = drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, {
       stroke: getStrokeColor$1(element, defaultStrokeColor),
       strokeWidth: 1,
       strokeDasharray: '8,3,1,3',
       fill: 'none',
       pointerEvents: 'none'
     });
19267
     return group;
   },
   'label': function(parentGfx, element) {
     return renderExternalLabel(parentGfx, element);
   },
   'bpmn:TextAnnotation': function(parentGfx, element) {
     var style = {
       'fill': 'none',
       'stroke': 'none'
     };
19278
     var textElement = drawRect(parentGfx, element.width, element.height, 0, 0, style);
19280
     var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.0,
         my: 0.0
       }
     });
19291
     drawPath(parentGfx, textPathData, {
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
19295
     var text = getSemantic(element).text || '';
     renderLabel(parentGfx, text, {
       box: element,
       align: 'left-top',
       padding: 5,
       style: {
         fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
       }
     });
19305
     return textElement;
   },
   'ParticipantMultiplicityMarker': function(parentGfx, element) {
     var markerPath = pathMap.getScaledPath('MARKER_PARALLEL', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: ((element.width / 2) / element.width),
         my: (element.height - 15) / element.height
       }
     });
19319
     drawMarker('participant-multiplicity', parentGfx, markerPath, {
       strokeWidth: 2,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
   },
   'SubProcessMarker': function(parentGfx, element) {
     var markerRect = drawRect(parentGfx, 14, 14, 0, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
19332
     // Process marker is placed in the middle of the box
     // therefore fixed values can be used here
     translate$2(markerRect, element.width / 2 - 7.5, element.height - 20);
19336
     var markerPath = pathMap.getScaledPath('MARKER_SUB_PROCESS', {
       xScaleFactor: 1.5,
       yScaleFactor: 1.5,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: (element.width / 2 - 7.5) / element.width,
         my: (element.height - 20) / element.height
       }
     });
19347
     drawMarker('sub-process', parentGfx, markerPath, {
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
   },
   'ParallelMarker': function(parentGfx, element, position) {
     var markerPath = pathMap.getScaledPath('MARKER_PARALLEL', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: ((element.width / 2 + position.parallel) / element.width),
         my: (element.height - 20) / element.height
       }
     });
19364
     drawMarker('parallel', parentGfx, markerPath, {
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
   },
   'SequentialMarker': function(parentGfx, element, position) {
     var markerPath = pathMap.getScaledPath('MARKER_SEQUENTIAL', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: ((element.width / 2 + position.seq) / element.width),
         my: (element.height - 19) / element.height
       }
     });
19381
     drawMarker('sequential', parentGfx, markerPath, {
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
   },
   'CompensationMarker': function(parentGfx, element, position) {
     var markerMath = pathMap.getScaledPath('MARKER_COMPENSATION', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: ((element.width / 2 + position.compensation) / element.width),
         my: (element.height - 13) / element.height
       }
     });
19398
     drawMarker('compensation', parentGfx, markerMath, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
   },
   'LoopMarker': function(parentGfx, element, position) {
     var markerPath = pathMap.getScaledPath('MARKER_LOOP', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: ((element.width / 2 + position.loop) / element.width),
         my: (element.height - 7) / element.height
       }
     });
19416
     drawMarker('loop', parentGfx, markerPath, {
       strokeWidth: 1,
       fill: getFillColor(element, defaultFillColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor),
       strokeLinecap: 'round',
       strokeMiterlimit: 0.5
     });
   },
   'AdhocMarker': function(parentGfx, element, position) {
     var markerPath = pathMap.getScaledPath('MARKER_ADHOC', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: ((element.width / 2 + position.adhoc) / element.width),
         my: (element.height - 15) / element.height
       }
     });
19436
     drawMarker('adhoc', parentGfx, markerPath, {
       strokeWidth: 1,
       fill: getStrokeColor$1(element, defaultStrokeColor),
       stroke: getStrokeColor$1(element, defaultStrokeColor)
     });
   }
 };
19444
 function attachTaskMarkers(parentGfx, element, taskMarkers) {
   var obj = getSemantic(element);
19447
   var subprocess = taskMarkers && taskMarkers.indexOf('SubProcessMarker') !== -1;
   var position;
19450
   if (subprocess) {
     position = {
       seq: -21,
       parallel: -22,
       compensation: -42,
       loop: -18,
       adhoc: 10
     };
   } else {
     position = {
       seq: -3,
       parallel: -6,
       compensation: -27,
       loop: 0,
       adhoc: 10
     };
   }
19468
   forEach$2(taskMarkers, function(marker) {
     renderer(marker)(parentGfx, element, position);
   });
19472
   if (obj.isForCompensation) {
     renderer('CompensationMarker')(parentGfx, element, position);
   }
19476
   if (obj.$type === 'bpmn:AdHocSubProcess') {
     renderer('AdhocMarker')(parentGfx, element, position);
   }
19480
   var loopCharacteristics = obj.loopCharacteristics,
       isSequential = loopCharacteristics && loopCharacteristics.isSequential;
19483
   if (loopCharacteristics) {
19485
     if (isSequential === undefined) {
       renderer('LoopMarker')(parentGfx, element, position);
     }
19489
     if (isSequential === false) {
       renderer('ParallelMarker')(parentGfx, element, position);
     }
19493
     if (isSequential === true) {
       renderer('SequentialMarker')(parentGfx, element, position);
     }
   }
 }
19499
 function renderDataItemCollection(parentGfx, element) {
19501
   var yPosition = (element.height - 18) / element.height;
19503
   var pathData = pathMap.getScaledPath('DATA_OBJECT_COLLECTION_PATH', {
     xScaleFactor: 1,
     yScaleFactor: 1,
     containerWidth: element.width,
     containerHeight: element.height,
     position: {
       mx: 0.33,
       my: yPosition
     }
   });
19514
   /* collection path */ drawPath(parentGfx, pathData, {
     strokeWidth: 2
   });
 }
19519
19520
 // extension API, use at your own risk
 this._drawPath = drawPath;
19523
 this._renderer = renderer;
}
19526
19527
inherits$1(BpmnRenderer, BaseRenderer);
19529
BpmnRenderer.$inject = [
 'config.bpmnRenderer',
 'eventBus',
 'styles',
 'pathMap',
 'canvas',
 'textRenderer'
];
19538
19539
BpmnRenderer.prototype.canRender = function(element) {
 return is$1(element, 'bpmn:BaseElement');
};
19543
BpmnRenderer.prototype.drawShape = function(parentGfx, element) {
 var type = element.type;
 var h = this._renderer(type);
19547
 /* jshint -W040 */
 return h(parentGfx, element);
};
19551
BpmnRenderer.prototype.drawConnection = function(parentGfx, element) {
 var type = element.type;
 var h = this._renderer(type);
19555
 /* jshint -W040 */
 return h(parentGfx, element);
};
19559
BpmnRenderer.prototype.getShapePath = function(element) {
19561
 if (is$1(element, 'bpmn:Event')) {
   return getCirclePath(element);
 }
19565
 if (is$1(element, 'bpmn:Activity')) {
   return getRoundRectPath(element, TASK_BORDER_RADIUS);
 }
19569
 if (is$1(element, 'bpmn:Gateway')) {
   return getDiamondPath(element);
 }
19573
 return getRectPath(element);
};
19576
var DEFAULT_BOX_PADDING = 0;
19578
var DEFAULT_LABEL_SIZE$1 = {
 width: 150,
 height: 50
};
19583
19584
function parseAlign(align) {
19586
 var parts = align.split('-');
19588
 return {
   horizontal: parts[0] || 'center',
   vertical: parts[1] || 'top'
 };
}
19594
function parsePadding(padding) {
19596
 if (isObject(padding)) {
   return assign({ top: 0, left: 0, right: 0, bottom: 0 }, padding);
 } else {
   return {
     top: padding,
     left: padding,
     right: padding,
     bottom: padding
   };
 }
}
19608
function getTextBBox(text, fakeText) {
19610
 fakeText.textContent = text;
19612
 var textBBox;
19614
 try {
   var bbox,
       emptyLine = text === '';
19618
   // add dummy text, when line is empty to
   // determine correct height
   fakeText.textContent = emptyLine ? 'dummy' : text;
19622
   textBBox = fakeText.getBBox();
19624
   // take text rendering related horizontal
   // padding into account
   bbox = {
     width: textBBox.width + textBBox.x * 2,
     height: textBBox.height
   };
19631
   if (emptyLine) {
19633
     // correct width
     bbox.width = 0;
   }
19637
   return bbox;
 } catch (e) {
   return { width: 0, height: 0 };
 }
}
19643
19644
/**
* Layout the next line and return the layouted element.
*
* Alters the lines passed.
*
* @param  {Array<string>} lines
* @return {Object} the line descriptor, an object { width, height, text }
*/
function layoutNext(lines, maxWidth, fakeText) {
19654
 var originalLine = lines.shift(),
     fitLine = originalLine;
19657
 var textBBox;
19659
 for (;;) {
   textBBox = getTextBBox(fitLine, fakeText);
19662
   textBBox.width = fitLine ? textBBox.width : 0;
19664
   // try to fit
   if (fitLine === ' ' || fitLine === '' || textBBox.width < Math.round(maxWidth) || fitLine.length < 2) {
     return fit(lines, fitLine, originalLine, textBBox);
   }
19669
   fitLine = shortenLine(fitLine, textBBox.width, maxWidth);
 }
}
19673
function fit(lines, fitLine, originalLine, textBBox) {
 if (fitLine.length < originalLine.length) {
   var remainder = originalLine.slice(fitLine.length).trim();
19677
   lines.unshift(remainder);
 }
19680
 return {
   width: textBBox.width,
   height: textBBox.height,
   text: fitLine
 };
}
19687
var SOFT_BREAK = '\u00AD';
19689
19690
/**
* Shortens a line based on spacing and hyphens.
* Returns the shortened result on success.
*
* @param  {string} line
* @param  {number} maxLength the maximum characters of the string
* @return {string} the shortened string
*/
function semanticShorten(line, maxLength) {
19700
 var parts = line.split(/(\s|-|\u00AD)/g),
     part,
     shortenedParts = [],
     length = 0;
19705
 // try to shorten via break chars
 if (parts.length > 1) {
19708
   while ((part = parts.shift())) {
     if (part.length + length < maxLength) {
       shortenedParts.push(part);
       length += part.length;
     } else {
19714
       // remove previous part, too if hyphen does not fit anymore
       if (part === '-' || part === SOFT_BREAK) {
         shortenedParts.pop();
       }
19719
       break;
     }
   }
 }
19724
 var last = shortenedParts[shortenedParts.length - 1];
19726
 // translate trailing soft break to actual hyphen
 if (last && last === SOFT_BREAK) {
   shortenedParts[shortenedParts.length - 1] = '-';
 }
19731
 return shortenedParts.join('');
}
19734
19735
function shortenLine(line, width, maxWidth) {
 var length = Math.max(line.length * (maxWidth / width), 1);
19738
 // try to shorten semantically (i.e. based on spaces and hyphens)
 var shortenedLine = semanticShorten(line, length);
19741
 if (!shortenedLine) {
19743
   // force shorten by cutting the long word
   shortenedLine = line.slice(0, Math.max(Math.round(length - 1), 1));
 }
19747
 return shortenedLine;
}
19750
19751
function getHelperSvg() {
 var helperSvg = document.getElementById('helper-svg');
19754
 if (!helperSvg) {
   helperSvg = create$1('svg');
19757
   attr$1(helperSvg, {
     id: 'helper-svg',
     width: 0,
     height: 0,
     visibility: 'hidden',
     position: 'fixed'
   });
19765
   document.body.appendChild(helperSvg);
 }
19768
 return helperSvg;
}
19771
19772
/**
* Creates a new label utility
*
* @param {Object} config
* @param {Dimensions} config.size
* @param {number} config.padding
* @param {Object} config.style
* @param {string} config.align
*/
function Text(config) {
19783
 this._config = assign({}, {
   size: DEFAULT_LABEL_SIZE$1,
   padding: DEFAULT_BOX_PADDING,
   style: {},
   align: 'center-top'
 }, config || {});
}
19791
/**
* Returns the layouted text as an SVG element.
*
* @param {string} text
* @param {Object} options
*
* @return {SVGElement}
*/
Text.prototype.createText = function(text, options) {
 return this.layoutText(text, options).element;
};
19803
/**
* Returns a labels layouted dimensions.
*
* @param {string} text to layout
* @param {Object} options
*
* @return {Dimensions}
*/
Text.prototype.getDimensions = function(text, options) {
 return this.layoutText(text, options).dimensions;
};
19815
/**
* Creates and returns a label and its bounding box.
*
* @method Text#createText
*
* @param {string} text the text to render on the label
* @param {Object} options
* @param {string} options.align how to align in the bounding box.
*                               Any of { 'center-middle', 'center-top' },
*                               defaults to 'center-top'.
* @param {string} options.style style to be applied to the text
* @param {boolean} options.fitBox indicates if box will be recalculated to
*                                 fit text
*
* @return {Object} { element, dimensions }
*/
Text.prototype.layoutText = function(text, options) {
 var box = assign({}, this._config.size, options.box),
     style = assign({}, 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;
19838
 var lineHeight = getLineHeight(style);
19840
 // we split text by lines and normalize
 // {soft break} + {line break} => { line break }
 var lines = text.split(/\u00AD?\r?\n/),
     layouted = [];
19845
 var maxWidth = box.width - padding.left - padding.right;
19847
 // ensure correct rendering by attaching helper text node to invisible SVG
 var helperText = create$1('text');
 attr$1(helperText, { x: 0, y: 0 });
 attr$1(helperText, style);
19852
 var helperSvg = getHelperSvg();
19854
 append(helperSvg, helperText);
19856
 while (lines.length) {
   layouted.push(layoutNext(lines, maxWidth, helperText));
 }
19860
 if (align.vertical === 'middle') {
   padding.top = padding.bottom = 0;
 }
19864
 var totalHeight = reduce(layouted, function(sum, line, idx) {
   return sum + (lineHeight || line.height);
 }, 0) + padding.top + padding.bottom;
19868
 var maxLineWidth = reduce(layouted, function(sum, line, idx) {
   return line.width > sum ? line.width : sum;
 }, 0);
19872
 // the y position of the next line
 var y = padding.top;
19875
 if (align.vertical === 'middle') {
   y += (box.height - totalHeight) / 2;
 }
19879
 // magic number initial offset
 y -= (lineHeight || layouted[0].height) / 4;
19882
19883
 var textElement = create$1('text');
19885
 attr$1(textElement, style);
19887
 // layout each line taking into account that parent
 // shape might resize to fit text size
 forEach$2(layouted, function(line) {
19891
   var x;
19893
   y += (lineHeight || line.height);
19895
   switch (align.horizontal) {
   case 'left':
     x = padding.left;
     break;
19900
   case 'right':
     x = ((fitBox ? maxLineWidth : maxWidth)
       - padding.right - line.width);
     break;
19905
   default:
19907
     // aka center
     x = Math.max((((fitBox ? maxLineWidth : maxWidth)
       - line.width) / 2 + padding.left), 0);
   }
19912
   var tspan = create$1('tspan');
   attr$1(tspan, { x: x, y: y });
19915
   tspan.textContent = line.text;
19917
   append(textElement, tspan);
 });
19920
 remove$2(helperText);
19922
 var dimensions = {
   width: maxLineWidth,
   height: totalHeight
 };
19927
 return {
   dimensions: dimensions,
   element: textElement
 };
};
19933
19934
function getLineHeight(style) {
 if ('fontSize' in style && 'lineHeight' in style) {
   return style.lineHeight * parseInt(style.fontSize, 10);
 }
}
19940
var DEFAULT_FONT_SIZE = 12;
var LINE_HEIGHT_RATIO = 1.2;
19943
var MIN_TEXT_ANNOTATION_HEIGHT = 30;
19945
19946
function TextRenderer(config) {
19948
 var defaultStyle = assign({
   fontFamily: 'Arial, sans-serif',
   fontSize: DEFAULT_FONT_SIZE,
   fontWeight: 'normal',
   lineHeight: LINE_HEIGHT_RATIO
 }, config && config.defaultStyle || {});
19955
 var fontSize = parseInt(defaultStyle.fontSize, 10) - 1;
19957
 var externalStyle = assign({}, defaultStyle, {
   fontSize: fontSize
 }, config && config.externalStyle || {});
19961
 var textUtil = new Text({
   style: defaultStyle
 });
19965
 /**
  * Get the new bounds of an externally rendered,
  * layouted label.
  *
  * @param  {Bounds} bounds
  * @param  {string} text
  *
  * @return {Bounds}
  */
 this.getExternalLabelBounds = function(bounds, text) {
19976
   var layoutedDimensions = textUtil.getDimensions(text, {
     box: {
       width: 90,
       height: 30,
       x: bounds.width / 2 + bounds.x,
       y: bounds.height / 2 + bounds.y
     },
     style: externalStyle
   });
19986
   // resize label shape to fit label text
   return {
     x: Math.round(bounds.x + bounds.width / 2 - layoutedDimensions.width / 2),
     y: Math.round(bounds.y),
     width: Math.ceil(layoutedDimensions.width),
     height: Math.ceil(layoutedDimensions.height)
   };
19994
 };
19996
 /**
  * Get the new bounds of text annotation.
  *
  * @param  {Bounds} bounds
  * @param  {string} text
  *
  * @return {Bounds}
  */
 this.getTextAnnotationBounds = function(bounds, text) {
20006
   var layoutedDimensions = textUtil.getDimensions(text, {
     box: bounds,
     style: defaultStyle,
     align: 'left-top',
     padding: 5
   });
20013
   return {
     x: bounds.x,
     y: bounds.y,
     width: bounds.width,
     height: Math.max(MIN_TEXT_ANNOTATION_HEIGHT, Math.round(layoutedDimensions.height))
   };
 };
20021
 /**
  * Create a layouted text element.
  *
  * @param {string} text
  * @param {Object} [options]
  *
  * @return {SVGElement} rendered text
  */
 this.createText = function(text, options) {
   return textUtil.createText(text, options || {});
 };
20033
 /**
  * Get default text style.
  */
 this.getDefaultStyle = function() {
   return defaultStyle;
 };
20040
 /**
  * Get the external text style.
  */
 this.getExternalStyle = function() {
   return externalStyle;
 };
20047
}
20049
TextRenderer.$inject = [
 'config.textRenderer'
];
20053
/**
* Map containing SVG paths needed by BpmnRenderer.
*/
20057
function PathMap() {
20059
 /**
  * Contains a map of path elements
  *
  * <h1>Path definition</h1>
  * A parameterized path is defined like this:
  * <pre>
  * 'GATEWAY_PARALLEL': {
  *   d: 'm {mx},{my} {e.x0},0 0,{e.x1} {e.x1},0 0,{e.y0} -{e.x1},0 0,{e.y1} ' +
         '-{e.x0},0 0,-{e.y1} -{e.x1},0 0,-{e.y0} {e.x1},0 z',
  *   height: 17.5,
  *   width:  17.5,
  *   heightElements: [2.5, 7.5],
  *   widthElements: [2.5, 7.5]
  * }
  * </pre>
  * <p>It's important to specify a correct <b>height and width</b> for the path as the scaling
  * is based on the ratio between the specified height and width in this object and the
  * height and width that is set as scale target (Note x,y coordinates will be scaled with
  * individual ratios).</p>
  * <p>The '<b>heightElements</b>' and '<b>widthElements</b>' array must contain the values that will be scaled.
  * The scaling is based on the computed ratios.
  * Coordinates on the y axis should be in the <b>heightElement</b>'s array, they will be scaled using
  * the computed ratio coefficient.
  * In the parameterized path the scaled values can be accessed through the 'e' object in {} brackets.
  *   <ul>
  *    <li>The values for the y axis can be accessed in the path string using {e.y0}, {e.y1}, ....</li>
  *    <li>The values for the x axis can be accessed in the path string using {e.x0}, {e.x1}, ....</li>
  *   </ul>
  *   The numbers x0, x1 respectively y0, y1, ... map to the corresponding array index.
  * </p>
  */
 this.pathMap = {
   'EVENT_MESSAGE': {
     d: 'm {mx},{my} l 0,{e.y1} l {e.x1},0 l 0,-{e.y1} z l {e.x0},{e.y0} l {e.x0},-{e.y0}',
     height: 36,
     width:  36,
     heightElements: [6, 14],
     widthElements: [10.5, 21]
   },
   'EVENT_SIGNAL': {
     d: 'M {mx},{my} l {e.x0},{e.y0} l -{e.x1},0 Z',
     height: 36,
     width: 36,
     heightElements: [18],
     widthElements: [10, 20]
   },
   'EVENT_ESCALATION': {
     d: 'M {mx},{my} l {e.x0},{e.y0} l -{e.x0},-{e.y1} l -{e.x0},{e.y1} Z',
     height: 36,
     width: 36,
     heightElements: [20, 7],
     widthElements: [8]
   },
   'EVENT_CONDITIONAL': {
     d: 'M {e.x0},{e.y0} l {e.x1},0 l 0,{e.y2} l -{e.x1},0 Z ' +
        'M {e.x2},{e.y3} l {e.x0},0 ' +
        'M {e.x2},{e.y4} l {e.x0},0 ' +
        'M {e.x2},{e.y5} l {e.x0},0 ' +
        'M {e.x2},{e.y6} l {e.x0},0 ' +
        'M {e.x2},{e.y7} l {e.x0},0 ' +
        'M {e.x2},{e.y8} l {e.x0},0 ',
     height: 36,
     width:  36,
     heightElements: [8.5, 14.5, 18, 11.5, 14.5, 17.5, 20.5, 23.5, 26.5],
     widthElements:  [10.5, 14.5, 12.5]
   },
   'EVENT_LINK': {
     d: 'm {mx},{my} 0,{e.y0} -{e.x1},0 0,{e.y1} {e.x1},0 0,{e.y0} {e.x0},-{e.y2} -{e.x0},-{e.y2} z',
     height: 36,
     width: 36,
     heightElements: [4.4375, 6.75, 7.8125],
     widthElements: [9.84375, 13.5]
   },
   'EVENT_ERROR': {
     d: 'm {mx},{my} {e.x0},-{e.y0} {e.x1},-{e.y1} {e.x2},{e.y2} {e.x3},-{e.y3} -{e.x4},{e.y4} -{e.x5},-{e.y5} z',
     height: 36,
     width: 36,
     heightElements: [0.023, 8.737, 8.151, 16.564, 10.591, 8.714],
     widthElements: [0.085, 6.672, 6.97, 4.273, 5.337, 6.636]
   },
   'EVENT_CANCEL_45': {
     d: 'm {mx},{my} -{e.x1},0 0,{e.x0} {e.x1},0 0,{e.y1} {e.x0},0 ' +
       '0,-{e.y1} {e.x1},0 0,-{e.y0} -{e.x1},0 0,-{e.y1} -{e.x0},0 z',
     height: 36,
     width: 36,
     heightElements: [4.75, 8.5],
     widthElements: [4.75, 8.5]
   },
   'EVENT_COMPENSATION': {
     d: 'm {mx},{my} {e.x0},-{e.y0} 0,{e.y1} z m {e.x1},-{e.y2} {e.x2},-{e.y3} 0,{e.y1} -{e.x2},-{e.y3} z',
     height: 36,
     width: 36,
     heightElements: [6.5, 13, 0.4, 6.1],
     widthElements: [9, 9.3, 8.7]
   },
   'EVENT_TIMER_WH': {
     d: 'M {mx},{my} l {e.x0},-{e.y0} m -{e.x0},{e.y0} l {e.x1},{e.y1} ',
     height: 36,
     width:  36,
     heightElements: [10, 2],
     widthElements: [3, 7]
   },
   'EVENT_TIMER_LINE': {
     d:  'M {mx},{my} ' +
         'm {e.x0},{e.y0} l -{e.x1},{e.y1} ',
     height: 36,
     width:  36,
     heightElements: [10, 3],
     widthElements: [0, 0]
   },
   'EVENT_MULTIPLE': {
     d:'m {mx},{my} {e.x1},-{e.y0} {e.x1},{e.y0} -{e.x0},{e.y1} -{e.x2},0 z',
     height: 36,
     width:  36,
     heightElements: [6.28099, 12.56199],
     widthElements: [3.1405, 9.42149, 12.56198]
   },
   'EVENT_PARALLEL_MULTIPLE': {
     d:'m {mx},{my} {e.x0},0 0,{e.y1} {e.x1},0 0,{e.y0} -{e.x1},0 0,{e.y1} ' +
       '-{e.x0},0 0,-{e.y1} -{e.x1},0 0,-{e.y0} {e.x1},0 z',
     height: 36,
     width:  36,
     heightElements: [2.56228, 7.68683],
     widthElements: [2.56228, 7.68683]
   },
   'GATEWAY_EXCLUSIVE': {
     d:'m {mx},{my} {e.x0},{e.y0} {e.x1},{e.y0} {e.x2},0 {e.x4},{e.y2} ' +
                   '{e.x4},{e.y1} {e.x2},0 {e.x1},{e.y3} {e.x0},{e.y3} ' +
                   '{e.x3},0 {e.x5},{e.y1} {e.x5},{e.y2} {e.x3},0 z',
     height: 17.5,
     width:  17.5,
     heightElements: [8.5, 6.5312, -6.5312, -8.5],
     widthElements:  [6.5, -6.5, 3, -3, 5, -5]
   },
   'GATEWAY_PARALLEL': {
     d:'m {mx},{my} 0,{e.y1} -{e.x1},0 0,{e.y0} {e.x1},0 0,{e.y1} {e.x0},0 ' +
       '0,-{e.y1} {e.x1},0 0,-{e.y0} -{e.x1},0 0,-{e.y1} -{e.x0},0 z',
     height: 30,
     width:  30,
     heightElements: [5, 12.5],
     widthElements: [5, 12.5]
   },
   'GATEWAY_EVENT_BASED': {
     d:'m {mx},{my} {e.x0},{e.y0} {e.x0},{e.y1} {e.x1},{e.y2} {e.x2},0 z',
     height: 11,
     width:  11,
     heightElements: [-6, 6, 12, -12],
     widthElements: [9, -3, -12]
   },
   'GATEWAY_COMPLEX': {
     d:'m {mx},{my} 0,{e.y0} -{e.x0},-{e.y1} -{e.x1},{e.y2} {e.x0},{e.y1} -{e.x2},0 0,{e.y3} ' +
       '{e.x2},0  -{e.x0},{e.y1} l {e.x1},{e.y2} {e.x0},-{e.y1} 0,{e.y0} {e.x3},0 0,-{e.y0} {e.x0},{e.y1} ' +
       '{e.x1},-{e.y2} -{e.x0},-{e.y1} {e.x2},0 0,-{e.y3} -{e.x2},0 {e.x0},-{e.y1} -{e.x1},-{e.y2} ' +
       '-{e.x0},{e.y1} 0,-{e.y0} -{e.x3},0 z',
     height: 17.125,
     width:  17.125,
     heightElements: [4.875, 3.4375, 2.125, 3],
     widthElements: [3.4375, 2.125, 4.875, 3]
   },
   'DATA_OBJECT_PATH': {
     d:'m 0,0 {e.x1},0 {e.x0},{e.y0} 0,{e.y1} -{e.x2},0 0,-{e.y2} {e.x1},0 0,{e.y0} {e.x0},0',
     height: 61,
     width:  51,
     heightElements: [10, 50, 60],
     widthElements: [10, 40, 50, 60]
   },
   'DATA_OBJECT_COLLECTION_PATH': {
     d: 'm{mx},{my} m 3,2 l 0,10 m 3,-10 l 0,10 m 3,-10 l 0,10',
     height: 10,
     width: 10,
     heightElements: [],
     widthElements: []
   },
   'DATA_ARROW': {
     d:'m 5,9 9,0 0,-3 5,5 -5,5 0,-3 -9,0 z',
     height: 61,
     width:  51,
     heightElements: [],
     widthElements: []
   },
   'DATA_STORE': {
     d:'m  {mx},{my} ' +
       'l  0,{e.y2} ' +
       'c  {e.x0},{e.y1} {e.x1},{e.y1}  {e.x2},0 ' +
       'l  0,-{e.y2} ' +
       'c -{e.x0},-{e.y1} -{e.x1},-{e.y1} -{e.x2},0' +
       'c  {e.x0},{e.y1} {e.x1},{e.y1}  {e.x2},0 ' +
       'm  -{e.x2},{e.y0}' +
       'c  {e.x0},{e.y1} {e.x1},{e.y1} {e.x2},0' +
       'm  -{e.x2},{e.y0}' +
       'c  {e.x0},{e.y1} {e.x1},{e.y1}  {e.x2},0',
     height: 61,
     width:  61,
     heightElements: [7, 10, 45],
     widthElements:  [2, 58, 60]
   },
   'TEXT_ANNOTATION': {
     d: 'm {mx}, {my} m 10,0 l -10,0 l 0,{e.y0} l 10,0',
     height: 30,
     width: 10,
     heightElements: [30],
     widthElements: [10]
   },
   'MARKER_SUB_PROCESS': {
     d: 'm{mx},{my} m 7,2 l 0,10 m -5,-5 l 10,0',
     height: 10,
     width: 10,
     heightElements: [],
     widthElements: []
   },
   'MARKER_PARALLEL': {
     d: 'm{mx},{my} m 3,2 l 0,10 m 3,-10 l 0,10 m 3,-10 l 0,10',
     height: 10,
     width: 10,
     heightElements: [],
     widthElements: []
   },
   'MARKER_SEQUENTIAL': {
     d: 'm{mx},{my} m 0,3 l 10,0 m -10,3 l 10,0 m -10,3 l 10,0',
     height: 10,
     width: 10,
     heightElements: [],
     widthElements: []
   },
   'MARKER_COMPENSATION': {
     d: 'm {mx},{my} 7,-5 0,10 z m 7.1,-0.3 6.9,-4.7 0,10 -6.9,-4.7 z',
     height: 10,
     width: 21,
     heightElements: [],
     widthElements: []
   },
   'MARKER_LOOP': {
     d: 'm {mx},{my} c 3.526979,0 6.386161,-2.829858 6.386161,-6.320661 0,-3.490806 -2.859182,-6.320661 ' +
       '-6.386161,-6.320661 -3.526978,0 -6.38616,2.829855 -6.38616,6.320661 0,1.745402 ' +
       '0.714797,3.325567 1.870463,4.469381 0.577834,0.571908 1.265885,1.034728 2.029916,1.35457 ' +
       'l -0.718163,-3.909793 m 0.718163,3.909793 -3.885211,0.802902',
     height: 13.9,
     width: 13.7,
     heightElements: [],
     widthElements: []
   },
   'MARKER_ADHOC': {
     d: 'm {mx},{my} m 0.84461,2.64411 c 1.05533,-1.23780996 2.64337,-2.07882 4.29653,-1.97997996 2.05163,0.0805 ' +
       '3.85579,1.15803 5.76082,1.79107 1.06385,0.34139996 2.24454,0.1438 3.18759,-0.43767 0.61743,-0.33642 ' +
       '1.2775,-0.64078 1.7542,-1.17511 0,0.56023 0,1.12046 0,1.6807 -0.98706,0.96237996 -2.29792,1.62393996 ' +
       '-3.6918,1.66181996 -1.24459,0.0927 -2.46671,-0.2491 -3.59505,-0.74812 -1.35789,-0.55965 ' +
       '-2.75133,-1.33436996 -4.27027,-1.18121996 -1.37741,0.14601 -2.41842,1.13685996 -3.44288,1.96782996 z',
     height: 4,
     width: 15,
     heightElements: [],
     widthElements: []
   },
   'TASK_TYPE_SEND': {
     d: 'm {mx},{my} l 0,{e.y1} l {e.x1},0 l 0,-{e.y1} z l {e.x0},{e.y0} l {e.x0},-{e.y0}',
     height: 14,
     width:  21,
     heightElements: [6, 14],
     widthElements: [10.5, 21]
   },
   'TASK_TYPE_SCRIPT': {
     d: 'm {mx},{my} c 9.966553,-6.27276 -8.000926,-7.91932 2.968968,-14.938 l -8.802728,0 ' +
       'c -10.969894,7.01868 6.997585,8.66524 -2.968967,14.938 z ' +
       'm -7,-12 l 5,0 ' +
       'm -4.5,3 l 4.5,0 ' +
       'm -3,3 l 5,0' +
       'm -4,3 l 5,0',
     height: 15,
     width:  12.6,
     heightElements: [6, 14],
     widthElements: [10.5, 21]
   },
   'TASK_TYPE_USER_1': {
     d: 'm {mx},{my} c 0.909,-0.845 1.594,-2.049 1.594,-3.385 0,-2.554 -1.805,-4.62199999 ' +
       '-4.357,-4.62199999 -2.55199998,0 -4.28799998,2.06799999 -4.28799998,4.62199999 0,1.348 ' +
       '0.974,2.562 1.89599998,3.405 -0.52899998,0.187 -5.669,2.097 -5.794,4.7560005 v 6.718 ' +
       'h 17 v -6.718 c 0,-2.2980005 -5.5279996,-4.5950005 -6.0509996,-4.7760005 z' +
       'm -8,6 l 0,5.5 m 11,0 l 0,-5'
   },
   'TASK_TYPE_USER_2': {
     d: 'm {mx},{my} m 2.162,1.009 c 0,2.4470005 -2.158,4.4310005 -4.821,4.4310005 ' +
       '-2.66499998,0 -4.822,-1.981 -4.822,-4.4310005 '
   },
   'TASK_TYPE_USER_3': {
     d: 'm {mx},{my} m -6.9,-3.80 c 0,0 2.25099998,-2.358 4.27399998,-1.177 2.024,1.181 4.221,1.537 ' +
       '4.124,0.965 -0.098,-0.57 -0.117,-3.79099999 -4.191,-4.13599999 -3.57499998,0.001 ' +
       '-4.20799998,3.36699999 -4.20699998,4.34799999 z'
   },
   'TASK_TYPE_MANUAL': {
     d: 'm {mx},{my} c 0.234,-0.01 5.604,0.008 8.029,0.004 0.808,0 1.271,-0.172 1.417,-0.752 0.227,-0.898 ' +
       '-0.334,-1.314 -1.338,-1.316 -2.467,-0.01 -7.886,-0.004 -8.108,-0.004 -0.014,-0.079 0.016,-0.533 0,-0.61 ' +
       '0.195,-0.042 8.507,0.006 9.616,0.002 0.877,-0.007 1.35,-0.438 1.353,-1.208 0.003,-0.768 -0.479,-1.09 ' +
       '-1.35,-1.091 -2.968,-0.002 -9.619,-0.013 -9.619,-0.013 v -0.591 c 0,0 5.052,-0.016 7.225,-0.016 ' +
       '0.888,-0.002 1.354,-0.416 1.351,-1.193 -0.006,-0.761 -0.492,-1.196 -1.361,-1.196 -3.473,-0.005 ' +
       '-10.86,-0.003 -11.0829995,-0.003 -0.022,-0.047 -0.045,-0.094 -0.069,-0.139 0.3939995,-0.319 ' +
       '2.0409995,-1.626 2.4149995,-2.017 0.469,-0.4870005 0.519,-1.1650005 0.162,-1.6040005 -0.414,-0.511 ' +
       '-0.973,-0.5 -1.48,-0.236 -1.4609995,0.764 -6.5999995,3.6430005 -7.7329995,4.2710005 -0.9,0.499 ' +
       '-1.516,1.253 -1.882,2.19 -0.37000002,0.95 -0.17,2.01 -0.166,2.979 0.004,0.718 -0.27300002,1.345 ' +
       '-0.055,2.063 0.629,2.087 2.425,3.312 4.859,3.318 4.6179995,0.014 9.2379995,-0.139 13.8569995,-0.158 ' +
       '0.755,-0.004 1.171,-0.301 1.182,-1.033 0.012,-0.754 -0.423,-0.969 -1.183,-0.973 -1.778,-0.01 ' +
       '-5.824,-0.004 -6.04,-0.004 10e-4,-0.084 0.003,-0.586 10e-4,-0.67 z'
   },
   'TASK_TYPE_INSTANTIATING_SEND': {
     d: 'm {mx},{my} l 0,8.4 l 12.6,0 l 0,-8.4 z l 6.3,3.6 l 6.3,-3.6'
   },
   'TASK_TYPE_SERVICE': {
     d: 'm {mx},{my} v -1.71335 c 0.352326,-0.0705 0.703932,-0.17838 1.047628,-0.32133 ' +
       '0.344416,-0.14465 0.665822,-0.32133 0.966377,-0.52145 l 1.19431,1.18005 1.567487,-1.57688 ' +
       '-1.195028,-1.18014 c 0.403376,-0.61394 0.683079,-1.29908 0.825447,-2.01824 l 1.622133,-0.01 ' +
       'v -2.2196 l -1.636514,0.01 c -0.07333,-0.35153 -0.178319,-0.70024 -0.323564,-1.04372 ' +
       '-0.145244,-0.34406 -0.321407,-0.6644 -0.522735,-0.96217 l 1.131035,-1.13631 -1.583305,-1.56293 ' +
       '-1.129598,1.13589 c -0.614052,-0.40108 -1.302883,-0.68093 -2.022633,-0.82247 l 0.0093,-1.61852 ' +
       'h -2.241173 l 0.0042,1.63124 c -0.353763,0.0736 -0.705369,0.17977 -1.049785,0.32371 -0.344415,0.14437 ' +
       '-0.665102,0.32092 -0.9635006,0.52046 l -1.1698628,-1.15823 -1.5667691,1.5792 1.1684265,1.15669 ' +
       'c -0.4026573,0.61283 -0.68308,1.29797 -0.8247287,2.01713 l -1.6588041,0.003 v 2.22174 ' +
       'l 1.6724648,-0.006 c 0.073327,0.35077 0.1797598,0.70243 0.3242851,1.04472 0.1452428,0.34448 ' +
       '0.3214064,0.6644 0.5227339,0.96066 l -1.1993431,1.19723 1.5840256,1.56011 1.1964668,-1.19348 ' +
       'c 0.6140517,0.40346 1.3028827,0.68232 2.0233517,0.82331 l 7.19e-4,1.69892 h 2.226848 z ' +
       'm 0.221462,-3.9957 c -1.788948,0.7502 -3.8576,-0.0928 -4.6097055,-1.87438 -0.7521065,-1.78321 ' +
       '0.090598,-3.84627 1.8802645,-4.59604 1.78823,-0.74936 3.856881,0.0929 4.608987,1.87437 ' +
       '0.752106,1.78165 -0.0906,3.84612 -1.879546,4.59605 z'
   },
   'TASK_TYPE_SERVICE_FILL': {
     d: 'm {mx},{my} c -1.788948,0.7502 -3.8576,-0.0928 -4.6097055,-1.87438 -0.7521065,-1.78321 ' +
       '0.090598,-3.84627 1.8802645,-4.59604 1.78823,-0.74936 3.856881,0.0929 4.608987,1.87437 ' +
       '0.752106,1.78165 -0.0906,3.84612 -1.879546,4.59605 z'
   },
   'TASK_TYPE_BUSINESS_RULE_HEADER': {
     d: 'm {mx},{my} 0,4 20,0 0,-4 z'
   },
   'TASK_TYPE_BUSINESS_RULE_MAIN': {
     d: 'm {mx},{my} 0,12 20,0 0,-12 z' +
       'm 0,8 l 20,0 ' +
       'm -13,-4 l 0,8'
   },
   'MESSAGE_FLOW_MARKER': {
     d: 'm {mx},{my} m -10.5 ,-7 l 0,14 l 21,0 l 0,-14 z l 10.5,6 l 10.5,-6'
   }
 };
20398
 this.getRawPath = function getRawPath(pathId) {
   return this.pathMap[pathId].d;
 };
20402
 /**
  * Scales the path to the given height and width.
  * <h1>Use case</h1>
  * <p>Use case is to scale the content of elements (event, gateways) based
  * on the element bounding box's size.
  * </p>
  * <h1>Why not transform</h1>
  * <p>Scaling a path with transform() will also scale the stroke and IE does not support
  * the option 'non-scaling-stroke' to prevent this.
  * Also there are use cases where only some parts of a path should be
  * scaled.</p>
  *
  * @param {string} pathId The ID of the path.
  * @param {Object} param <p>
  *   Example param object scales the path to 60% size of the container (data.width, data.height).
  *   <pre>
  *   {
  *     xScaleFactor: 0.6,
  *     yScaleFactor:0.6,
  *     containerWidth: data.width,
  *     containerHeight: data.height,
  *     position: {
  *       mx: 0.46,
  *       my: 0.2,
  *     }
  *   }
  *   </pre>
  *   <ul>
  *    <li>targetpathwidth = xScaleFactor * containerWidth</li>
  *    <li>targetpathheight = yScaleFactor * containerHeight</li>
  *    <li>Position is used to set the starting coordinate of the path. M is computed:
   *    <ul>
   *      <li>position.x * containerWidth</li>
   *      <li>position.y * containerHeight</li>
   *    </ul>
   *    Center of the container <pre> position: {
  *       mx: 0.5,
  *       my: 0.5,
  *     }</pre>
  *     Upper left corner of the container
  *     <pre> position: {
  *       mx: 0.0,
  *       my: 0.0,
  *     }</pre>
  *    </li>
  *   </ul>
  * </p>
  *
  */
 this.getScaledPath = function getScaledPath(pathId, param) {
   var rawPath = this.pathMap[pathId];
20454
   // positioning
   // compute the start point of the path
   var mx, my;
20458
   if (param.abspos) {
     mx = param.abspos.x;
     my = param.abspos.y;
   } else {
     mx = param.containerWidth * param.position.mx;
     my = param.containerHeight * param.position.my;
   }
20466
   var coordinates = {}; // map for the scaled coordinates
   if (param.position) {
20469
     // path
     var heightRatio = (param.containerHeight / rawPath.height) * param.yScaleFactor;
     var widthRatio = (param.containerWidth / rawPath.width) * param.xScaleFactor;
20473
20474
     // Apply height ratio
     for (var heightIndex = 0; heightIndex < rawPath.heightElements.length; heightIndex++) {
       coordinates['y' + heightIndex] = rawPath.heightElements[heightIndex] * heightRatio;
     }
20479
     // Apply width ratio
     for (var widthIndex = 0; widthIndex < rawPath.widthElements.length; widthIndex++) {
       coordinates['x' + widthIndex] = rawPath.widthElements[widthIndex] * widthRatio;
     }
   }
20485
   // Apply value to raw path
   var path = format(
     rawPath.d, {
       mx: mx,
       my: my,
       e: coordinates
     }
   );
   return path;
 };
}
20497
// helpers //////////////////////
20499
// copied and adjusted from https://github.com/adobe-webplatform/Snap.svg/blob/master/src/svg.js
var tokenRegex = /\{([^{}]+)\}/g,
   objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g; // matches .xxxxx or ["xxxxx"] to run over object properties
20503
function replacer(all, key, obj) {
 var res = obj;
 key.replace(objNotationRegex, function(all, name, quote, quotedName, isFunc) {
   name = name || quotedName;
   if (res) {
     if (name in res) {
       res = res[name];
     }
     typeof res == 'function' && isFunc && (res = res());
   }
 });
 res = (res == null || res == obj ? all : res) + '';
20516
 return res;
}
20519
function format(str, obj) {
 return String(str).replace(tokenRegex, function(all, key) {
   return replacer(all, key, obj);
 });
}
20525
var DrawModule = {
 __init__: [ 'bpmnRenderer' ],
 bpmnRenderer: [ 'type', BpmnRenderer ],
 textRenderer: [ 'type', TextRenderer ],
 pathMap: [ 'type', PathMap ]
};
20532
/**
* A simple translation stub to be used for multi-language support
* in diagrams. Can be easily replaced with a more sophisticated
* solution.
*
* @example
*
* // use it inside any diagram component by injecting `translate`.
*
* function MyService(translate) {
*   alert(translate('HELLO {you}', { you: 'You!' }));
* }
*
* @param {string} template to interpolate
* @param {Object} [replacements] a map with substitutes
*
* @return {string} the translated string
*/
function translate$1(template, replacements) {
20552
 replacements = replacements || {};
20554
 return template.replace(/{([^}]+)}/g, function(_, key) {
   return replacements[key] || '{' + key + '}';
 });
}
20559
var translate = {
 translate: [ 'value', translate$1 ]
};
20563
var DEFAULT_LABEL_SIZE = {
 width: 90,
 height: 20
};
20568
var FLOW_LABEL_INDENT = 15;
20570
20571
/**
* Returns true if the given semantic has an external label
*
* @param {BpmnElement} semantic
* @return {boolean} true if has label
*/
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');
}
20589
/**
* Returns true if the given element has an external label
*
* @param {djs.model.shape} element
* @return {boolean} true if has label
*/
function hasExternalLabel(element) {
 return isLabel$6(element.label);
}
20599
/**
* Get the position for sequence flow labels
*
* @param  {Array<Point>} waypoints
* @return {Point} the label position
*/
function getFlowLabelPosition(waypoints) {
20607
 // get the waypoints mid
 var mid = waypoints.length / 2 - 1;
20610
 var first = waypoints[Math.floor(mid)];
 var second = waypoints[Math.ceil(mid + 0.01)];
20613
 // get position
 var position = getWaypointsMid(waypoints);
20616
 // calculate angle
 var angle = Math.atan((second.y - first.y) / (second.x - first.x));
20619
 var x = position.x,
     y = position.y;
20622
 if (Math.abs(angle) < Math.PI / 2) {
   y -= FLOW_LABEL_INDENT;
 } else {
   x += FLOW_LABEL_INDENT;
 }
20628
 return { x: x, y: y };
}
20631
20632
/**
* Get the middle of a number of waypoints
*
* @param  {Array<Point>} waypoints
* @return {Point} the mid point
*/
function getWaypointsMid(waypoints) {
20640
 var mid = waypoints.length / 2 - 1;
20642
 var first = waypoints[Math.floor(mid)];
 var second = waypoints[Math.ceil(mid + 0.01)];
20645
 return {
   x: first.x + (second.x - first.x) / 2,
   y: first.y + (second.y - first.y) / 2
 };
}
20651
20652
function getExternalLabelMid(element) {
20654
 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.height / 2
   };
 } else {
   return {
     x: element.x + element.width / 2,
     y: element.y + element.height + DEFAULT_LABEL_SIZE.height / 2
   };
 }
}
20669
20670
/**
* Returns the bounds of an elements label, parsed from the elements DI or
* generated from its bounds.
*
* @param {BpmndDi} di
* @param {djs.model.Base} element
*/
function getExternalLabelBounds(di, element) {
20679
 var mid,
     size,
     bounds,
     label = di.label;
20684
 if (label && label.bounds) {
   bounds = label.bounds;
20687
   size = {
     width: Math.max(DEFAULT_LABEL_SIZE.width, bounds.width),
     height: bounds.height
   };
20692
   mid = {
     x: bounds.x + bounds.width / 2,
     y: bounds.y + bounds.height / 2
   };
 } else {
20698
   mid = getExternalLabelMid(element);
20700
   size = DEFAULT_LABEL_SIZE;
 }
20703
 return assign({
   x: mid.x - size.width / 2,
   y: mid.y - size.height / 2
 }, size);
}
20709
function isLabel$6(element) {
 return element && !!element.labelTarget;
}
20713
/**
* @param {ModdleElement} semantic
* @param {ModdleElement} di
* @param {Object} [attrs=null]
*
* @return {Object}
*/
function elementData(semantic, di, attrs) {
 return assign({
   id: semantic.id,
   type: semantic.$type,
   businessObject: semantic,
   di: di
 }, attrs);
}
20729
function getWaypoints(di, source, target) {
20731
 var waypoints = di.waypoint;
20733
 if (!waypoints || waypoints.length < 2) {
   return [ getMid(source), getMid(target) ];
 }
20737
 return waypoints.map(function(p) {
   return { x: p.x, y: p.y };
 });
}
20742
function notYetDrawn(translate, semantic, refSemantic, property) {
 return new Error(translate('element {element} referenced by {referenced}#{property} not yet drawn', {
   element: elementToString(refSemantic),
   referenced: elementToString(semantic),
   property: property
 }));
}
20750
20751
/**
* An importer that adds bpmn elements to the canvas
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {ElementFactory} elementFactory
* @param {ElementRegistry} elementRegistry
* @param {Function} translate
* @param {TextRenderer} textRenderer
*/
function BpmnImporter(
   eventBus, canvas, elementFactory,
   elementRegistry, translate, textRenderer) {
20765
 this._eventBus = eventBus;
 this._canvas = canvas;
 this._elementFactory = elementFactory;
 this._elementRegistry = elementRegistry;
 this._translate = translate;
 this._textRenderer = textRenderer;
}
20773
BpmnImporter.$inject = [
 'eventBus',
 'canvas',
 'elementFactory',
 'elementRegistry',
 'translate',
 'textRenderer'
];
20782
20783
/**
* Add bpmn element (semantic) to the canvas onto the
* specified parent shape.
*/
BpmnImporter.prototype.add = function(semantic, di, parentElement) {
 var element,
     translate = this._translate,
     hidden;
20792
 var parentIndex;
20794
 // ROOT ELEMENT
 // handle the special case that we deal with a
 // invisible root element (process, subprocess or collaboration)
 if (is$1(di, 'bpmndi:BPMNPlane')) {
20799
   var attrs = is$1(semantic, 'bpmn:SubProcess')
     ? { id: semantic.id + '_plane' }
     : {};
20803
   // add a virtual element (not being drawn)
   element = this._elementFactory.createRoot(elementData(semantic, di, attrs));
20806
   this._canvas.addRootElement(element);
 }
20809
 // SHAPE
 else if (is$1(di, 'bpmndi:BPMNShape')) {
20812
   var collapsed = !isExpanded(semantic, di),
       isFrame = isFrameElement(semantic);
20815
   hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
20817
   var bounds = di.bounds;
20819
   element = this._elementFactory.createShape(elementData(semantic, di, {
     collapsed: collapsed,
     hidden: hidden,
     x: Math.round(bounds.x),
     y: Math.round(bounds.y),
     width: Math.round(bounds.width),
     height: Math.round(bounds.height),
     isFrame: isFrame
   }));
20829
   if (is$1(semantic, 'bpmn:BoundaryEvent')) {
     this._attachBoundary(semantic, element);
   }
20833
   // insert lanes behind other flow nodes (cf. #727)
   if (is$1(semantic, 'bpmn:Lane')) {
     parentIndex = 0;
   }
20838
   if (is$1(semantic, 'bpmn:DataStoreReference')) {
20840
     // check whether data store is inside our outside of its semantic parent
     if (!isPointInsideBBox$1(parentElement, getMid(bounds))) {
       parentElement = this._canvas.findRoot(parentElement);
     }
   }
20846
   this._canvas.addShape(element, parentElement, parentIndex);
 }
20849
 // CONNECTION
 else if (is$1(di, 'bpmndi:BPMNEdge')) {
20852
   var source = this._getSource(semantic),
       target = this._getTarget(semantic);
20855
   hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
20857
   element = this._elementFactory.createConnection(elementData(semantic, di, {
     hidden: hidden,
     source: source,
     target: target,
     waypoints: getWaypoints(di, source, target)
   }));
20864
   if (is$1(semantic, 'bpmn:DataAssociation')) {
20866
     // render always on top; this ensures DataAssociations
     // are rendered correctly across different "hacks" people
     // love to model such as cross participant / sub process
     // associations
     parentElement = this._canvas.findRoot(parentElement);
   }
20873
   // insert sequence flows behind other flow nodes (cf. #727)
   if (is$1(semantic, 'bpmn:SequenceFlow')) {
     parentIndex = 0;
   }
20878
   this._canvas.addConnection(element, parentElement, parentIndex);
 } else {
   throw new Error(translate('unknown di {di} for element {semantic}', {
     di: elementToString(di),
     semantic: elementToString(semantic)
   }));
 }
20886
 // (optional) LABEL
 if (isLabelExternal(semantic) && getLabel(element)) {
   this.addLabel(semantic, di, element);
 }
20891
20892
 this._eventBus.fire('bpmnElement.added', { element: element });
20894
 return element;
};
20897
20898
/**
* Attach the boundary element to the given host
*
* @param {ModdleElement} boundarySemantic
* @param {djs.model.Base} boundaryElement
*/
BpmnImporter.prototype._attachBoundary = function(boundarySemantic, boundaryElement) {
 var translate = this._translate;
 var hostSemantic = boundarySemantic.attachedToRef;
20908
 if (!hostSemantic) {
   throw new Error(translate('missing {semantic}#attachedToRef', {
     semantic: elementToString(boundarySemantic)
   }));
 }
20914
 var host = this._elementRegistry.get(hostSemantic.id),
     attachers = host && host.attachers;
20917
 if (!host) {
   throw notYetDrawn(translate, boundarySemantic, hostSemantic, 'attachedToRef');
 }
20921
 // wire element.host <> host.attachers
 boundaryElement.host = host;
20924
 if (!attachers) {
   host.attachers = attachers = [];
 }
20928
 if (attachers.indexOf(boundaryElement) === -1) {
   attachers.push(boundaryElement);
 }
};
20933
20934
/**
* add label for an element
*/
BpmnImporter.prototype.addLabel = function(semantic, di, element) {
 var bounds,
     text,
     label;
20942
 bounds = getExternalLabelBounds(di, element);
20944
 text = getLabel(element);
20946
 if (text) {
20948
   // get corrected bounds from actual layouted text
   bounds = this._textRenderer.getExternalLabelBounds(bounds, text);
 }
20952
 label = this._elementFactory.createLabel(elementData(semantic, di, {
   id: semantic.id + '_label',
   labelTarget: element,
   type: 'label',
   hidden: element.hidden || !getLabel(element),
   x: Math.round(bounds.x),
   y: Math.round(bounds.y),
   width: Math.round(bounds.width),
   height: Math.round(bounds.height)
 }));
20963
 return this._canvas.addShape(label, element.parent);
};
20966
/**
* Return the drawn connection end based on the given side.
*
* @throws {Error} if the end is not yet drawn
*/
BpmnImporter.prototype._getEnd = function(semantic, side) {
20973
 var element,
     refSemantic,
     type = semantic.$type,
     translate = this._translate;
20978
 refSemantic = semantic[side + 'Ref'];
20980
 // handle mysterious isMany DataAssociation#sourceRef
 if (side === 'source' && type === 'bpmn:DataInputAssociation') {
   refSemantic = refSemantic && refSemantic[0];
 }
20985
 // fix source / target for DataInputAssociation / DataOutputAssociation
 if (side === 'source' && type === 'bpmn:DataOutputAssociation' ||
     side === 'target' && type === 'bpmn:DataInputAssociation') {
20989
   refSemantic = semantic.$parent;
 }
20992
 element = refSemantic && this._getElement(refSemantic);
20994
 if (element) {
   return element;
 }
20998
 if (refSemantic) {
   throw notYetDrawn(translate, semantic, refSemantic, side + 'Ref');
 } else {
   throw new Error(translate('{semantic}#{side} Ref not specified', {
     semantic: elementToString(semantic),
     side: side
   }));
 }
};
21008
BpmnImporter.prototype._getSource = function(semantic) {
 return this._getEnd(semantic, 'source');
};
21012
BpmnImporter.prototype._getTarget = function(semantic) {
 return this._getEnd(semantic, 'target');
};
21016
21017
BpmnImporter.prototype._getElement = function(semantic) {
 return this._elementRegistry.get(semantic.id);
};
21021
21022
// helpers ////////////////////
21024
function isPointInsideBBox$1(bbox, point) {
 var x = point.x,
     y = point.y;
21028
 return x >= bbox.x &&
   x <= bbox.x + bbox.width &&
   y >= bbox.y &&
   y <= bbox.y + bbox.height;
}
21034
function isFrameElement(semantic) {
 return is$1(semantic, 'bpmn:Group');
}
21038
var ImportModule = {
 __depends__: [
   translate
 ],
 bpmnImporter: [ 'type', BpmnImporter ]
};
21045
var CoreModule = {
 __depends__: [
   DrawModule,
   ImportModule
 ]
};
21052
function __stopPropagation(event) {
 if (!event || typeof event.stopPropagation !== 'function') {
   return;
 }
21057
 event.stopPropagation();
}
21060
21061
function getOriginal$1(event) {
 return event.originalEvent || event.srcEvent;
}
21065
21066
function stopPropagation$1(event, immediate) {
 __stopPropagation(event);
 __stopPropagation(getOriginal$1(event));
}
21071
21072
function toPoint(event) {
21074
 if (event.pointers && event.pointers.length) {
   event = event.pointers[0];
 }
21078
 if (event.touches && event.touches.length) {
   event = event.touches[0];
 }
21082
 return event ? {
   x: event.clientX,
   y: event.clientY
 } : null;
}
21088
function isMac() {
 return (/mac/i).test(navigator.platform);
}
21092
function isButton(event, button) {
 return (getOriginal$1(event) || event).button === button;
}
21096
function isPrimaryButton(event) {
21098
 // button === 0 -> left áka primary mouse button
 return isButton(event, 0);
}
21102
function isAuxiliaryButton(event) {
21104
 // button === 1 -> auxiliary áka wheel button
 return isButton(event, 1);
}
21108
function hasPrimaryModifier(event) {
 var originalEvent = getOriginal$1(event) || event;
21111
 if (!isPrimaryButton(event)) {
   return false;
 }
21115
 // Use cmd as primary modifier key for mac OS
 if (isMac()) {
   return originalEvent.metaKey;
 } else {
   return originalEvent.ctrlKey;
 }
}
21123
21124
function hasSecondaryModifier(event) {
 var originalEvent = getOriginal$1(event) || event;
21127
 return isPrimaryButton(event) && originalEvent.shiftKey;
}
21130
function allowAll(event) { return true; }
21132
function allowPrimaryAndAuxiliary(event) {
 return isPrimaryButton(event) || isAuxiliaryButton(event);
}
21136
var LOW_PRIORITY$o = 500;
21138
21139
/**
* A plugin that provides interaction events for diagram elements.
*
* It emits the following events:
*
*   * element.click
*   * element.contextmenu
*   * element.dblclick
*   * element.hover
*   * element.mousedown
*   * element.mousemove
*   * element.mouseup
*   * element.out
*
* Each event is a tuple { element, gfx, originalEvent }.
*
* Canceling the event via Event#preventDefault()
* prevents the original DOM operation.
*
* @param {EventBus} eventBus
*/
function InteractionEvents(eventBus, elementRegistry, styles) {
21162
 var self = this;
21164
 /**
  * Fire an interaction event.
  *
  * @param {string} type local event name, e.g. element.click.
  * @param {DOMEvent} event native event
  * @param {djs.model.Base} [element] the diagram element to emit the event on;
  *                                   defaults to the event target
  */
 function fire(type, event, element) {
21174
   if (isIgnored(type, event)) {
     return;
   }
21178
   var target, gfx, returnValue;
21180
   if (!element) {
     target = event.delegateTarget || event.target;
21183
     if (target) {
       gfx = target;
       element = elementRegistry.get(gfx);
     }
   } else {
     gfx = elementRegistry.getGraphics(element);
   }
21191
   if (!gfx || !element) {
     return;
   }
21195
   returnValue = eventBus.fire(type, {
     element: element,
     gfx: gfx,
     originalEvent: event
   });
21201
   if (returnValue === false) {
     event.stopPropagation();
     event.preventDefault();
   }
 }
21207
 // TODO(nikku): document this
 var handlers = {};
21210
 function mouseHandler(localEventName) {
   return handlers[localEventName];
 }
21214
 function isIgnored(localEventName, event) {
21216
   var filter = ignoredFilters[localEventName] || isPrimaryButton;
21218
   // only react on left mouse button interactions
   // except for interaction events that are enabled
   // for secundary mouse button
   return !filter(event);
 }
21224
 var bindings = {
   click: 'element.click',
   contextmenu: 'element.contextmenu',
   dblclick: 'element.dblclick',
   mousedown: 'element.mousedown',
   mousemove: 'element.mousemove',
   mouseover: 'element.hover',
   mouseout: 'element.out',
   mouseup: 'element.mouseup',
 };
21235
 var ignoredFilters = {
   'element.contextmenu': allowAll,
   'element.mousedown': allowPrimaryAndAuxiliary,
   'element.mouseup': allowPrimaryAndAuxiliary,
   'element.click': allowPrimaryAndAuxiliary,
   'element.dblclick': allowPrimaryAndAuxiliary
 };
21243
21244
 // manual event trigger //////////
21246
 /**
  * Trigger an interaction event (based on a native dom event)
  * on the target shape or connection.
  *
  * @param {string} eventName the name of the triggered DOM event
  * @param {MouseEvent} event
  * @param {djs.model.Base} targetElement
  */
 function triggerMouseEvent(eventName, event, targetElement) {
21256
   // i.e. element.mousedown...
   var localEventName = bindings[eventName];
21259
   if (!localEventName) {
     throw new Error('unmapped DOM event name <' + eventName + '>');
   }
21263
   return fire(localEventName, event, targetElement);
 }
21266
21267
 var ELEMENT_SELECTOR = 'svg, .djs-element';
21269
 // event handling ///////
21271
 function registerEvent(node, event, localEvent, ignoredFilter) {
21273
   var handler = handlers[localEvent] = function(event) {
     fire(localEvent, event);
   };
21277
   if (ignoredFilter) {
     ignoredFilters[localEvent] = ignoredFilter;
   }
21281
   handler.$delegate = delegate.bind(node, ELEMENT_SELECTOR, event, handler);
 }
21284
 function unregisterEvent(node, event, localEvent) {
21286
   var handler = mouseHandler(localEvent);
21288
   if (!handler) {
     return;
   }
21292
   delegate.unbind(node, event, handler.$delegate);
 }
21295
 function registerEvents(svg) {
   forEach$2(bindings, function(val, key) {
     registerEvent(svg, key, val);
   });
 }
21301
 function unregisterEvents(svg) {
   forEach$2(bindings, function(val, key) {
     unregisterEvent(svg, key, val);
   });
 }
21307
 eventBus.on('canvas.destroy', function(event) {
   unregisterEvents(event.svg);
 });
21311
 eventBus.on('canvas.init', function(event) {
   registerEvents(event.svg);
 });
21315
21316
 // hit box updating ////////////////
21318
 eventBus.on([ 'shape.added', 'connection.added' ], function(event) {
   var element = event.element,
       gfx = event.gfx;
21322
   eventBus.fire('interactionEvents.createHit', { element: element, gfx: gfx });
 });
21325
 // Update djs-hit on change.
 // A low priortity is necessary, because djs-hit of labels has to be updated
 // after the label bounds have been updated in the renderer.
 eventBus.on([
   'shape.changed',
   'connection.changed'
 ], LOW_PRIORITY$o, function(event) {
21333
   var element = event.element,
       gfx = event.gfx;
21336
   eventBus.fire('interactionEvents.updateHit', { element: element, gfx: gfx });
 });
21339
 eventBus.on('interactionEvents.createHit', LOW_PRIORITY$o, function(event) {
   var element = event.element,
       gfx = event.gfx;
21343
   self.createDefaultHit(element, gfx);
 });
21346
 eventBus.on('interactionEvents.updateHit', function(event) {
   var element = event.element,
       gfx = event.gfx;
21350
   self.updateDefaultHit(element, gfx);
 });
21353
21354
 // hit styles ////////////
21356
 var STROKE_HIT_STYLE = createHitStyle('djs-hit djs-hit-stroke');
21358
 var CLICK_STROKE_HIT_STYLE = createHitStyle('djs-hit djs-hit-click-stroke');
21360
 var ALL_HIT_STYLE = createHitStyle('djs-hit djs-hit-all');
21362
 var NO_MOVE_HIT_STYLE = createHitStyle('djs-hit djs-hit-no-move');
21364
 var HIT_TYPES = {
   'all': ALL_HIT_STYLE,
   'click-stroke': CLICK_STROKE_HIT_STYLE,
   'stroke': STROKE_HIT_STYLE,
   'no-move': NO_MOVE_HIT_STYLE
 };
21371
 function createHitStyle(classNames, attrs) {
21373
   attrs = assign({
     stroke: 'white',
     strokeWidth: 15
   }, attrs || {});
21378
   return styles.cls(classNames, [ 'no-fill', 'no-border' ], attrs);
 }
21381
21382
 // style helpers ///////////////
21384
 function applyStyle(hit, type) {
21386
   var attrs = HIT_TYPES[type];
21388
   if (!attrs) {
     throw new Error('invalid hit type <' + type + '>');
   }
21392
   attr$1(hit, attrs);
21394
   return hit;
 }
21397
 function appendHit(gfx, hit) {
   append(gfx, hit);
 }
21401
21402
 // API
21404
 /**
  * Remove hints on the given graphics.
  *
  * @param {SVGElement} gfx
  */
 this.removeHits = function(gfx) {
   var hits = all('.djs-hit', gfx);
21412
   forEach$2(hits, remove$2);
 };
21415
 /**
  * Create default hit for the given element.
  *
  * @param {djs.model.Base} element
  * @param {SVGElement} gfx
  *
  * @return {SVGElement} created hit
  */
 this.createDefaultHit = function(element, gfx) {
   var waypoints = element.waypoints,
       isFrame = element.isFrame,
       boxType;
21428
   if (waypoints) {
     return this.createWaypointsHit(gfx, waypoints);
   } else {
21432
     boxType = isFrame ? 'stroke' : 'all';
21434
     return this.createBoxHit(gfx, boxType, {
       width: element.width,
       height: element.height
     });
   }
 };
21441
 /**
  * Create hits for the given waypoints.
  *
  * @param {SVGElement} gfx
  * @param {Array<Point>} waypoints
  *
  * @return {SVGElement}
  */
 this.createWaypointsHit = function(gfx, waypoints) {
21451
   var hit = createLine(waypoints);
21453
   applyStyle(hit, 'stroke');
21455
   appendHit(gfx, hit);
21457
   return hit;
 };
21460
 /**
  * Create hits for a box.
  *
  * @param {SVGElement} gfx
  * @param {string} hitType
  * @param {Object} attrs
  *
  * @return {SVGElement}
  */
 this.createBoxHit = function(gfx, type, attrs) {
21471
   attrs = assign({
     x: 0,
     y: 0
   }, attrs);
21476
   var hit = create$1('rect');
21478
   applyStyle(hit, type);
21480
   attr$1(hit, attrs);
21482
   appendHit(gfx, hit);
21484
   return hit;
 };
21487
 /**
  * Update default hit of the element.
  *
  * @param  {djs.model.Base} element
  * @param  {SVGElement} gfx
  *
  * @return {SVGElement} updated hit
  */
 this.updateDefaultHit = function(element, gfx) {
21497
   var hit = query('.djs-hit', gfx);
21499
   if (!hit) {
     return;
   }
21503
   if (element.waypoints) {
     updateLine(hit, element.waypoints);
   } else {
     attr$1(hit, {
       width: element.width,
       height: element.height
     });
   }
21512
   return hit;
 };
21515
 this.fire = fire;
21517
 this.triggerMouseEvent = triggerMouseEvent;
21519
 this.mouseHandler = mouseHandler;
21521
 this.registerEvent = registerEvent;
 this.unregisterEvent = unregisterEvent;
}
21525
21526
InteractionEvents.$inject = [
 'eventBus',
 'elementRegistry',
 'styles'
];
21532
21533
/**
* An event indicating that the mouse hovered over an element
*
* @event element.hover
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21544
/**
* An event indicating that the mouse has left an element
*
* @event element.out
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21555
/**
* An event indicating that the mouse has clicked an element
*
* @event element.click
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21566
/**
* An event indicating that the mouse has double clicked an element
*
* @event element.dblclick
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21577
/**
* An event indicating that the mouse has gone down on an element.
*
* @event element.mousedown
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21588
/**
* An event indicating that the mouse has gone up on an element.
*
* @event element.mouseup
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21599
/**
* An event indicating that the context menu action is triggered
* via mouse or touch controls.
*
* @event element.contextmenu
*
* @type {Object}
* @property {djs.model.Base} element
* @property {SVGElement} gfx
* @property {Event} originalEvent
*/
21611
var InteractionEventsModule$1 = {
 __init__: [ 'interactionEvents' ],
 interactionEvents: [ 'type', InteractionEvents ]
};
21616
var LOW_PRIORITY$n = 500;
21618
21619
/**
* @class
*
* A plugin that adds an outline to shapes and connections that may be activated and styled
* via CSS classes.
*
* @param {EventBus} eventBus
* @param {Styles} styles
* @param {ElementRegistry} elementRegistry
*/
function Outline(eventBus, styles, elementRegistry) {
21631
 this.offset = 6;
21633
 var OUTLINE_STYLE = styles.cls('djs-outline', [ 'no-fill' ]);
21635
 var self = this;
21637
 function createOutline(gfx, bounds) {
   var outline = create$1('rect');
21640
   attr$1(outline, assign({
     x: 10,
     y: 10,
     width: 100,
     height: 100
   }, OUTLINE_STYLE));
21647
   append(gfx, outline);
21649
   return outline;
 }
21652
 // A low priortity is necessary, because outlines of labels have to be updated
 // after the label bounds have been updated in the renderer.
 eventBus.on([ 'shape.added', 'shape.changed' ], LOW_PRIORITY$n, function(event) {
   var element = event.element,
       gfx = event.gfx;
21658
   var outline = query('.djs-outline', gfx);
21660
   if (!outline) {
     outline = createOutline(gfx);
   }
21664
   self.updateShapeOutline(outline, element);
 });
21667
 eventBus.on([ 'connection.added', 'connection.changed' ], function(event) {
   var element = event.element,
       gfx = event.gfx;
21671
   var outline = query('.djs-outline', gfx);
21673
   if (!outline) {
     outline = createOutline(gfx);
   }
21677
   self.updateConnectionOutline(outline, element);
 });
}
21681
21682
/**
* Updates the outline of a shape respecting the dimension of the
* element and an outline offset.
*
* @param  {SVGElement} outline
* @param  {djs.model.Base} element
*/
Outline.prototype.updateShapeOutline = function(outline, element) {
21691
 attr$1(outline, {
   x: -this.offset,
   y: -this.offset,
   width: element.width + this.offset * 2,
   height: element.height + this.offset * 2
 });
21698
};
21700
21701
/**
* Updates the outline of a connection respecting the bounding box of
* the connection and an outline offset.
*
* @param  {SVGElement} outline
* @param  {djs.model.Base} element
*/
Outline.prototype.updateConnectionOutline = function(outline, connection) {
21710
 var bbox = getBBox(connection);
21712
 attr$1(outline, {
   x: bbox.x - this.offset,
   y: bbox.y - this.offset,
   width: bbox.width + this.offset * 2,
   height: bbox.height + this.offset * 2
 });
21719
};
21721
21722
Outline.$inject = [ 'eventBus', 'styles', 'elementRegistry' ];
21724
var OutlineModule = {
 __init__: [ 'outline' ],
 outline: [ 'type', Outline ]
};
21729
/**
* A service that offers the current selection in a diagram.
* Offers the api to control the selection, too.
*
* @class
*
* @param {EventBus} eventBus the event bus
*/
function Selection(eventBus, canvas) {
21739
 this._eventBus = eventBus;
 this._canvas = canvas;
21742
 this._selectedElements = [];
21744
 var self = this;
21746
 eventBus.on([ 'shape.remove', 'connection.remove' ], function(e) {
   var element = e.element;
   self.deselect(element);
 });
21751
 eventBus.on([ 'diagram.clear', 'root.set' ], function(e) {
   self.select(null);
 });
}
21756
Selection.$inject = [ 'eventBus', 'canvas' ];
21758
21759
Selection.prototype.deselect = function(element) {
 var selectedElements = this._selectedElements;
21762
 var idx = selectedElements.indexOf(element);
21764
 if (idx !== -1) {
   var oldSelection = selectedElements.slice();
21767
   selectedElements.splice(idx, 1);
21769
   this._eventBus.fire('selection.changed', { oldSelection: oldSelection, newSelection: selectedElements });
 }
};
21773
21774
Selection.prototype.get = function() {
 return this._selectedElements;
};
21778
Selection.prototype.isSelected = function(element) {
 return this._selectedElements.indexOf(element) !== -1;
};
21782
21783
/**
* This method selects one or more elements on the diagram.
*
* By passing an additional add parameter you can decide whether or not the element(s)
* should be added to the already existing selection or not.
*
* @method Selection#select
*
* @param  {Object|Object[]} elements element or array of elements to be selected
* @param  {boolean} [add] whether the element(s) should be appended to the current selection, defaults to false
*/
Selection.prototype.select = function(elements, add) {
 var selectedElements = this._selectedElements,
     oldSelection = selectedElements.slice();
21798
 if (!isArray$4(elements)) {
   elements = elements ? [ elements ] : [];
 }
21802
 var canvas = this._canvas;
21804
 var rootElement = canvas.getRootElement();
21806
 elements = elements.filter(function(element) {
   var elementRoot = canvas.findRoot(element);
21809
   return rootElement === elementRoot;
 });
21812
 // selection may be cleared by passing an empty array or null
 // to the method
 if (add) {
   forEach$2(elements, function(element) {
     if (selectedElements.indexOf(element) !== -1) {
21818
       // already selected
       return;
     } else {
       selectedElements.push(element);
     }
   });
 } else {
   this._selectedElements = selectedElements = elements.slice();
 }
21828
 this._eventBus.fire('selection.changed', { oldSelection: oldSelection, newSelection: selectedElements });
};
21831
var MARKER_HOVER = 'hover',
   MARKER_SELECTED = 'selected';
21834
21835
/**
* A plugin that adds a visible selection UI to shapes and connections
* by appending the <code>hover</code> and <code>selected</code> classes to them.
*
* @class
*
* Makes elements selectable, too.
*
* @param {EventBus} events
* @param {SelectionService} selection
* @param {Canvas} canvas
*/
function SelectionVisuals(events, canvas, selection, styles) {
21849
 this._multiSelectionBox = null;
21851
 function addMarker(e, cls) {
   canvas.addMarker(e, cls);
 }
21855
 function removeMarker(e, cls) {
   canvas.removeMarker(e, cls);
 }
21859
 events.on('element.hover', function(event) {
   addMarker(event.element, MARKER_HOVER);
 });
21863
 events.on('element.out', function(event) {
   removeMarker(event.element, MARKER_HOVER);
 });
21867
 events.on('selection.changed', function(event) {
21869
   function deselect(s) {
     removeMarker(s, MARKER_SELECTED);
   }
21873
   function select(s) {
     addMarker(s, MARKER_SELECTED);
   }
21877
   var oldSelection = event.oldSelection,
       newSelection = event.newSelection;
21880
   forEach$2(oldSelection, function(e) {
     if (newSelection.indexOf(e) === -1) {
       deselect(e);
     }
   });
21886
   forEach$2(newSelection, function(e) {
     if (oldSelection.indexOf(e) === -1) {
       select(e);
     }
   });
 });
}
21894
SelectionVisuals.$inject = [
 'eventBus',
 'canvas',
 'selection',
 'styles'
];
21901
function SelectionBehavior(eventBus, selection, canvas, elementRegistry) {
21903
 // Select elements on create
 eventBus.on('create.end', 500, function(event) {
   var context = event.context,
       canExecute = context.canExecute,
       elements = context.elements,
       hints = context.hints || {},
       autoSelect = hints.autoSelect;
21911
   if (canExecute) {
     if (autoSelect === false) {
21914
       // Select no elements
       return;
     }
21918
     if (isArray$4(autoSelect)) {
       selection.select(autoSelect);
     } else {
21922
       // Select all elements by default
       selection.select(elements.filter(isShown));
     }
   }
 });
21928
 // Select connection targets on connect
 eventBus.on('connect.end', 500, function(event) {
   var context = event.context,
       canExecute = context.canExecute,
       hover = context.hover;
21934
   if (canExecute && hover) {
     selection.select(hover);
   }
 });
21939
 // Select shapes on move
 eventBus.on('shape.move.end', 500, function(event) {
   var previousSelection = event.previousSelection || [];
21943
   var shape = elementRegistry.get(event.context.shape.id);
21945
   // Always select main shape on move
   var isSelected = find(previousSelection, function(selectedShape) {
     return shape.id === selectedShape.id;
   });
21950
   if (!isSelected) {
     selection.select(shape);
   }
 });
21955
 // Select elements on click
 eventBus.on('element.click', function(event) {
21958
   if (!isPrimaryButton(event)) {
     return;
   }
21962
   var element = event.element;
21964
   if (element === canvas.getRootElement()) {
     element = null;
   }
21968
   var isSelected = selection.isSelected(element),
       isMultiSelect = selection.get().length > 1;
21971
   // Add to selection if CTRL or SHIFT pressed
   var add = hasPrimaryModifier(event) || hasSecondaryModifier(event);
21974
   if (isSelected && isMultiSelect) {
     if (add) {
21977
       // Deselect element
       return selection.deselect(element);
     } else {
21981
       // Select element only
       return selection.select(element);
     }
   } else if (!isSelected) {
21986
     // Select element
     selection.select(element, add);
   } else {
21990
     // Deselect element
     selection.deselect(element);
   }
 });
}
21996
SelectionBehavior.$inject = [
 'eventBus',
 'selection',
 'canvas',
 'elementRegistry'
];
22003
22004
function isShown(element) {
 return !element.hidden;
}
22008
var SelectionModule = {
 __init__: [ 'selectionVisuals', 'selectionBehavior' ],
 __depends__: [
   InteractionEventsModule$1,
   OutlineModule
 ],
 selection: [ 'type', Selection ],
 selectionVisuals: [ 'type', SelectionVisuals ],
 selectionBehavior: [ 'type', SelectionBehavior ]
};
22019
/**
* Util that provides unique IDs.
*
* @class djs.util.IdGenerator
* @constructor
* @memberOf djs.util
*
* The ids can be customized via a given prefix and contain a random value to avoid collisions.
*
* @param {string} prefix a prefix to prepend to generated ids (for better readability)
*/
function IdGenerator(prefix) {
22032
 this._counter = 0;
 this._prefix = (prefix ? prefix + '-' : '') + Math.floor(Math.random() * 1000000000) + '-';
}
22036
/**
* Returns a next unique ID.
*
* @method djs.util.IdGenerator#next
*
* @returns {string} the id
*/
IdGenerator.prototype.next = function() {
 return this._prefix + (++this._counter);
};
22047
// document wide unique overlay ids
var ids$1 = new IdGenerator('ov');
22050
var LOW_PRIORITY$m = 500;
22052
22053
/**
* A service that allows users to attach overlays to diagram elements.
*
* The overlay service will take care of overlay positioning during updates.
*
* @example
*
* // add a pink badge on the top left of the shape
* overlays.add(someShape, {
*   position: {
*     top: -5,
*     left: -5
*   },
*   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>'
* });
*
* // or add via shape id
*
* overlays.add('some-element-id', {
*   position: {
*     top: -5,
*     left: -5
*   }
*   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>'
* });
*
* // or add with optional type
*
* overlays.add(someShape, 'badge', {
*   position: {
*     top: -5,
*     left: -5
*   }
*   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>'
* });
*
*
* // remove an overlay
*
* var id = overlays.add(...);
* overlays.remove(id);
*
*
* You may configure overlay defaults during tool by providing a `config` module
* with `overlays.defaults` as an entry:
*
* {
*   overlays: {
*     defaults: {
*       show: {
*         minZoom: 0.7,
*         maxZoom: 5.0
*       },
*       scale: {
*         min: 1
*       }
*     }
* }
*
* @param {Object} config
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {ElementRegistry} elementRegistry
*/
function Overlays(config, eventBus, canvas, elementRegistry) {
22119
 this._eventBus = eventBus;
 this._canvas = canvas;
 this._elementRegistry = elementRegistry;
22123
 this._ids = ids$1;
22125
 this._overlayDefaults = assign({
22127
   // no show constraints
   show: null,
22130
   // always scale
   scale: true
 }, config && config.defaults);
22134
 /**
  * Mapping overlayId -> overlay
  */
 this._overlays = {};
22139
 /**
  * Mapping elementId -> overlay container
  */
 this._overlayContainers = [];
22144
 // root html element for all overlays
 this._overlayRoot = createRoot$1(canvas.getContainer());
22147
 this._init();
}
22150
22151
Overlays.$inject = [
 'config.overlays',
 'eventBus',
 'canvas',
 'elementRegistry'
];
22158
22159
/**
* Returns the overlay with the specified id or a list of overlays
* for an element with a given type.
*
* @example
*
* // return the single overlay with the given id
* overlays.get('some-id');
*
* // return all overlays for the shape
* overlays.get({ element: someShape });
*
* // return all overlays on shape with type 'badge'
* overlays.get({ element: someShape, type: 'badge' });
*
* // shape can also be specified as id
* overlays.get({ element: 'element-id', type: 'badge' });
*
*
* @param {Object} search
* @param {string} [search.id]
* @param {string|djs.model.Base} [search.element]
* @param {string} [search.type]
*
* @return {Object|Array<Object>} the overlay(s)
*/
Overlays.prototype.get = function(search) {
22187
 if (isString(search)) {
   search = { id: search };
 }
22191
 if (isString(search.element)) {
   search.element = this._elementRegistry.get(search.element);
 }
22195
 if (search.element) {
   var container = this._getOverlayContainer(search.element, true);
22198
   // 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();
   } else {
     return [];
   }
 } else
 if (search.type) {
   return filter(this._overlays, matchPattern({ type: search.type }));
 } else {
22209
   // return single element when searching by id
   return search.id ? this._overlays[search.id] : null;
 }
};
22214
/**
* Adds a HTML overlay to an element.
*
* @param {string|djs.model.Base}   element   attach overlay to this shape
* @param {string}                  [type]    optional type to assign to the overlay
* @param {Object}                  overlay   the overlay configuration
*
* @param {string|DOMElement}       overlay.html                 html element to use as an overlay
* @param {Object}                  [overlay.show]               show configuration
* @param {number}                  [overlay.show.minZoom]       minimal zoom level to show the overlay
* @param {number}                  [overlay.show.maxZoom]       maximum zoom level to show the overlay
* @param {Object}                  overlay.position             where to attach the overlay
* @param {number}                  [overlay.position.left]      relative to element bbox left attachment
* @param {number}                  [overlay.position.top]       relative to element bbox top attachment
* @param {number}                  [overlay.position.bottom]    relative to element bbox bottom attachment
* @param {number}                  [overlay.position.right]     relative to element bbox right attachment
* @param {boolean|Object}          [overlay.scale=true]         false to preserve the same size regardless of
*                                                               diagram zoom
* @param {number}                  [overlay.scale.min]
* @param {number}                  [overlay.scale.max]
*
* @return {string}                 id that may be used to reference the overlay for update or removal
*/
Overlays.prototype.add = function(element, type, overlay) {
22239
 if (isObject(type)) {
   overlay = type;
   type = null;
 }
22244
 if (!element.id) {
   element = this._elementRegistry.get(element);
 }
22248
 if (!overlay.position) {
   throw new Error('must specifiy overlay position');
 }
22252
 if (!overlay.html) {
   throw new Error('must specifiy overlay html');
 }
22256
 if (!element) {
   throw new Error('invalid element specified');
 }
22260
 var id = this._ids.next();
22262
 overlay = assign({}, this._overlayDefaults, overlay, {
   id: id,
   type: type,
   element: element,
   html: overlay.html
 });
22269
 this._addOverlay(overlay);
22271
 return id;
};
22274
22275
/**
* Remove an overlay with the given id or all overlays matching the given filter.
*
* @see Overlays#get for filter options.
*
* @param {string|object} [filter]
*/
Overlays.prototype.remove = function(filter) {
22284
 var overlays = this.get(filter) || [];
22286
 if (!isArray$4(overlays)) {
   overlays = [ overlays ];
 }
22290
 var self = this;
22292
 forEach$2(overlays, function(overlay) {
22294
   var container = self._getOverlayContainer(overlay.element, true);
22296
   if (overlay) {
     remove$1(overlay.html);
     remove$1(overlay.htmlContainer);
22300
     delete overlay.htmlContainer;
     delete overlay.element;
22303
     delete self._overlays[overlay.id];
   }
22306
   if (container) {
     var idx = container.overlays.indexOf(overlay);
     if (idx !== -1) {
       container.overlays.splice(idx, 1);
     }
   }
 });
22314
};
22316
22317
Overlays.prototype.show = function() {
 setVisible$1(this._overlayRoot);
};
22321
22322
Overlays.prototype.hide = function() {
 setVisible$1(this._overlayRoot, false);
};
22326
Overlays.prototype.clear = function() {
 this._overlays = {};
22329
 this._overlayContainers = [];
22331
 clear(this._overlayRoot);
};
22334
Overlays.prototype._updateOverlayContainer = function(container) {
 var element = container.element,
     html = container.html;
22338
 // update container left,top according to the elements x,y coordinates
 // this ensures we can attach child elements relative to this container
22341
 var x = element.x,
     y = element.y;
22344
 if (element.waypoints) {
   var bbox = getBBox(element);
   x = bbox.x;
   y = bbox.y;
 }
22350
 setPosition$1(html, x, y);
22352
 attr(container.html, 'data-container-id', element.id);
};
22355
22356
Overlays.prototype._updateOverlay = function(overlay) {
22358
 var position = overlay.position,
     htmlContainer = overlay.htmlContainer,
     element = overlay.element;
22362
 // update overlay html relative to shape because
 // it is already positioned on the element
22365
 // update relative
 var left = position.left,
     top = position.top;
22369
 if (position.right !== undefined) {
22371
   var width;
22373
   if (element.waypoints) {
     width = getBBox(element).width;
   } else {
     width = element.width;
   }
22379
   left = position.right * -1 + width;
 }
22382
 if (position.bottom !== undefined) {
22384
   var height;
22386
   if (element.waypoints) {
     height = getBBox(element).height;
   } else {
     height = element.height;
   }
22392
   top = position.bottom * -1 + height;
 }
22395
 setPosition$1(htmlContainer, left || 0, top || 0);
 this._updateOverlayVisibilty(overlay, this._canvas.viewbox());
};
22399
22400
Overlays.prototype._createOverlayContainer = function(element) {
 var html = domify('<div class="djs-overlays" />');
 assign$1(html, { position: 'absolute' });
22404
 this._overlayRoot.appendChild(html);
22406
 var container = {
   html: html,
   element: element,
   overlays: []
 };
22412
 this._updateOverlayContainer(container);
22414
 this._overlayContainers.push(container);
22416
 return container;
};
22419
22420
Overlays.prototype._updateRoot = function(viewbox) {
 var scale = viewbox.scale || 1;
22423
 var matrix = 'matrix(' +
 [
   scale,
   0,
   0,
   scale,
   -1 * viewbox.x * scale,
   -1 * viewbox.y * scale
 ].join(',') +
 ')';
22434
 setTransform$1(this._overlayRoot, matrix);
};
22437
22438
Overlays.prototype._getOverlayContainer = function(element, raw) {
 var container = find(this._overlayContainers, function(c) {
   return c.element === element;
 });
22443
22444
 if (!container && !raw) {
   return this._createOverlayContainer(element);
 }
22448
 return container;
};
22451
22452
Overlays.prototype._addOverlay = function(overlay) {
22454
 var id = overlay.id,
     element = overlay.element,
     html = overlay.html,
     htmlContainer,
     overlayContainer;
22460
 // unwrap jquery (for those who need it)
 if (html.get && html.constructor.prototype.jquery) {
   html = html.get(0);
 }
22465
 // create proper html elements from
 // overlay HTML strings
 if (isString(html)) {
   html = domify(html);
 }
22471
 overlayContainer = this._getOverlayContainer(element);
22473
 htmlContainer = domify('<div class="djs-overlay" data-overlay-id="' + id + '">');
 assign$1(htmlContainer, { position: 'absolute' });
22476
 htmlContainer.appendChild(html);
22478
 if (overlay.type) {
   classes(htmlContainer).add('djs-overlay-' + overlay.type);
 }
22482
 var elementRoot = this._canvas.findRoot(element);
 var activeRoot = this._canvas.getRootElement();
22485
 setVisible$1(htmlContainer, elementRoot === activeRoot);
22487
 overlay.htmlContainer = htmlContainer;
22489
 overlayContainer.overlays.push(overlay);
 overlayContainer.html.appendChild(htmlContainer);
22492
 this._overlays[id] = overlay;
22494
 this._updateOverlay(overlay);
 this._updateOverlayVisibilty(overlay, this._canvas.viewbox());
};
22498
22499
Overlays.prototype._updateOverlayVisibilty = function(overlay, viewbox) {
 var show = overlay.show,
     rootElement = this._canvas.findRoot(overlay.element),
     minZoom = show && show.minZoom,
     maxZoom = show && show.maxZoom,
     htmlContainer = overlay.htmlContainer,
     activeRootElement = this._canvas.getRootElement(),
     visible = true;
22508
 if (rootElement !== activeRootElement) {
   visible = false;
 } else if (show) {
   if (
     (isDefined(minZoom) && minZoom > viewbox.scale) ||
     (isDefined(maxZoom) && maxZoom < viewbox.scale)
   ) {
     visible = false;
   }
 }
22519
 setVisible$1(htmlContainer, visible);
22521
 this._updateOverlayScale(overlay, viewbox);
};
22524
22525
Overlays.prototype._updateOverlayScale = function(overlay, viewbox) {
 var shouldScale = overlay.scale,
     minScale,
     maxScale,
     htmlContainer = overlay.htmlContainer;
22531
 var scale, transform = '';
22533
 if (shouldScale !== true) {
22535
   if (shouldScale === false) {
     minScale = 1;
     maxScale = 1;
   } else {
     minScale = shouldScale.min;
     maxScale = shouldScale.max;
   }
22543
   if (isDefined(minScale) && viewbox.scale < minScale) {
     scale = (1 / viewbox.scale || 1) * minScale;
   }
22547
   if (isDefined(maxScale) && viewbox.scale > maxScale) {
     scale = (1 / viewbox.scale || 1) * maxScale;
   }
 }
22552
 if (isDefined(scale)) {
   transform = 'scale(' + scale + ',' + scale + ')';
 }
22556
 setTransform$1(htmlContainer, transform);
};
22559
22560
Overlays.prototype._updateOverlaysVisibilty = function(viewbox) {
22562
 var self = this;
22564
 forEach$2(this._overlays, function(overlay) {
   self._updateOverlayVisibilty(overlay, viewbox);
 });
};
22569
22570
Overlays.prototype._init = function() {
22572
 var eventBus = this._eventBus;
22574
 var self = this;
22576
22577
 // scroll/zoom integration
22579
 function updateViewbox(viewbox) {
   self._updateRoot(viewbox);
   self._updateOverlaysVisibilty(viewbox);
22583
   self.show();
 }
22586
 eventBus.on('canvas.viewbox.changing', function(event) {
   self.hide();
 });
22590
 eventBus.on('canvas.viewbox.changed', function(event) {
   updateViewbox(event.viewbox);
 });
22594
22595
 // remove integration
22597
 eventBus.on([ 'shape.remove', 'connection.remove' ], function(e) {
   var element = e.element;
   var overlays = self.get({ element: element });
22601
   forEach$2(overlays, function(o) {
     self.remove(o.id);
   });
22605
   var container = self._getOverlayContainer(element);
22607
   if (container) {
     remove$1(container.html);
     var i = self._overlayContainers.indexOf(container);
     if (i !== -1) {
       self._overlayContainers.splice(i, 1);
     }
   }
 });
22616
22617
 // move integration
22619
 eventBus.on('element.changed', LOW_PRIORITY$m, function(e) {
   var element = e.element;
22622
   var container = self._getOverlayContainer(element, true);
22624
   if (container) {
     forEach$2(container.overlays, function(overlay) {
       self._updateOverlay(overlay);
     });
22629
     self._updateOverlayContainer(container);
   }
 });
22633
22634
 // marker integration, simply add them on the overlays as classes, too.
22636
 eventBus.on('element.marker.update', function(e) {
   var container = self._getOverlayContainer(e.element, true);
   if (container) {
     classes(container.html)[e.add ? 'add' : 'remove'](e.marker);
   }
 });
22643
22644
 eventBus.on('root.set', function() {
   self._updateOverlaysVisibilty(self._canvas.viewbox());
 });
22648
 // clear overlays with diagram
22650
 eventBus.on('diagram.clear', this.clear, this);
};
22653
22654
22655
// helpers /////////////////////////////
22657
function createRoot$1(parentNode) {
 var root = domify(
   '<div class="djs-overlay-container" />'
 );
22662
 assign$1(root, {
   position: 'absolute',
   width: 0,
   height: 0
 });
22668
 parentNode.insertBefore(root, parentNode.firstChild);
22670
 return root;
}
22673
function setPosition$1(el, x, y) {
 assign$1(el, { left: x + 'px', top: y + 'px' });
}
22677
function setVisible$1(el, visible) {
 el.style.display = visible === false ? 'none' : '';
}
22681
function setTransform$1(el, transform) {
22683
 el.style['transform-origin'] = 'top left';
22685
 [ '', '-ms-', '-webkit-' ].forEach(function(prefix) {
   el.style[prefix + 'transform'] = transform;
 });
}
22690
var OverlaysModule = {
 __init__: [ 'overlays' ],
 overlays: [ 'type', Overlays ]
};
22695
/**
* Adds change support to the diagram, including
*
* <ul>
*   <li>redrawing shapes and connections on change</li>
* </ul>
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {ElementRegistry} elementRegistry
* @param {GraphicsFactory} graphicsFactory
*/
function ChangeSupport(
   eventBus, canvas, elementRegistry,
   graphicsFactory) {
22711
22712
 // redraw shapes / connections on change
22714
 eventBus.on('element.changed', function(event) {
22716
   var element = event.element;
22718
   // element might have been deleted and replaced by new element with same ID
   // thus check for parent of element except for root element
   if (element.parent || element === canvas.getRootElement()) {
     event.gfx = elementRegistry.getGraphics(element);
   }
22724
   // shape + gfx may have been deleted
   if (!event.gfx) {
     return;
   }
22729
   eventBus.fire(getType(element) + '.changed', event);
 });
22732
 eventBus.on('elements.changed', function(event) {
22734
   var elements = event.elements;
22736
   elements.forEach(function(e) {
     eventBus.fire('element.changed', { element: e });
   });
22740
   graphicsFactory.updateContainments(elements);
 });
22743
 eventBus.on('shape.changed', function(event) {
   graphicsFactory.update('shape', event.element, event.gfx);
 });
22747
 eventBus.on('connection.changed', function(event) {
   graphicsFactory.update('connection', event.element, event.gfx);
 });
}
22752
ChangeSupport.$inject = [
 'eventBus',
 'canvas',
 'elementRegistry',
 'graphicsFactory'
];
22759
var ChangeSupportModule = {
 __init__: [ 'changeSupport' ],
 changeSupport: [ 'type', ChangeSupport ]
};
22764
var DEFAULT_PRIORITY$4 = 1000;
22766
/**
* A utility that can be used to plug-in into the command execution for
* extension and/or validation.
*
* @param {EventBus} eventBus
*
* @example
*
* import inherits from 'inherits';
*
* import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
*
* function CommandLogger(eventBus) {
*   CommandInterceptor.call(this, eventBus);
*
*   this.preExecute(function(event) {
*     console.log('command pre-execute', event);
*   });
* }
*
* inherits(CommandLogger, CommandInterceptor);
*
*/
function CommandInterceptor(eventBus) {
 this._eventBus = eventBus;
}
22793
CommandInterceptor.$inject = [ 'eventBus' ];
22795
function unwrapEvent(fn, that) {
 return function(event) {
   return fn.call(that || null, event.context, event.command, event);
 };
}
22801
/**
* Register an interceptor for a command execution
*
* @param {string|Array<string>} [events] list of commands to register on
* @param {string} [hook] command hook, i.e. preExecute, executed to listen on
* @param {number} [priority] the priority on which to hook into the execution
* @param {Function} handlerFn interceptor to be invoked with (event)
* @param {boolean} unwrap if true, unwrap the event and pass (context, command, event) to the
*                          listener instead
* @param {Object} [that] Pass context (`this`) to the handler function
*/
CommandInterceptor.prototype.on = function(events, hook, priority, handlerFn, unwrap, that) {
22814
 if (isFunction(hook) || isNumber(hook)) {
   that = unwrap;
   unwrap = handlerFn;
   handlerFn = priority;
   priority = hook;
   hook = null;
 }
22822
 if (isFunction(priority)) {
   that = unwrap;
   unwrap = handlerFn;
   handlerFn = priority;
   priority = DEFAULT_PRIORITY$4;
 }
22829
 if (isObject(unwrap)) {
   that = unwrap;
   unwrap = false;
 }
22834
 if (!isFunction(handlerFn)) {
   throw new Error('handlerFn must be a function');
 }
22838
 if (!isArray$4(events)) {
   events = [ events ];
 }
22842
 var eventBus = this._eventBus;
22844
 forEach$2(events, function(event) {
22846
   // concat commandStack(.event)?(.hook)?
   var fullEvent = [ 'commandStack', event, hook ].filter(function(e) { return e; }).join('.');
22849
   eventBus.on(fullEvent, priority, unwrap ? unwrapEvent(handlerFn, that) : handlerFn, that);
 });
};
22853
22854
var hooks = [
 'canExecute',
 'preExecute',
 'preExecuted',
 'execute',
 'executed',
 'postExecute',
 'postExecuted',
 'revert',
 'reverted'
];
22866
/*
* Install hook shortcuts
*
* This will generate the CommandInterceptor#(preExecute|...|reverted) methods
* which will in term forward to CommandInterceptor#on.
*/
forEach$2(hooks, function(hook) {
22874
 /**
  * {canExecute|preExecute|preExecuted|execute|executed|postExecute|postExecuted|revert|reverted}
  *
  * A named hook for plugging into the command execution
  *
  * @param {string|Array<string>} [events] list of commands to register on
  * @param {number} [priority] the priority on which to hook into the execution
  * @param {Function} handlerFn interceptor to be invoked with (event)
  * @param {boolean} [unwrap=false] if true, unwrap the event and pass (context, command, event) to the
  *                          listener instead
  * @param {Object} [that] Pass context (`this`) to the handler function
  */
 CommandInterceptor.prototype[hook] = function(events, priority, handlerFn, unwrap, that) {
22888
   if (isFunction(events) || isNumber(events)) {
     that = unwrap;
     unwrap = handlerFn;
     handlerFn = priority;
     priority = events;
     events = null;
   }
22896
   this.on(events, hook, priority, handlerFn, unwrap, that);
 };
});
22900
/**
* A modeling behavior that ensures we set the correct root element
* as we undo and redo commands.
*
* @param {Canvas} canvas
* @param {didi.Injector} injector
*/
function RootElementsBehavior(canvas, injector) {
22909
 injector.invoke(CommandInterceptor, this);
22911
 this.executed(function(event) {
   var context = event.context;
22914
   if (context.rootElement) {
     canvas.setRootElement(context.rootElement);
   } else {
     context.rootElement = canvas.getRootElement();
   }
 });
22921
 this.revert(function(event) {
   var context = event.context;
22924
   if (context.rootElement) {
     canvas.setRootElement(context.rootElement);
   }
 });
}
22930
inherits$1(RootElementsBehavior, CommandInterceptor);
22932
RootElementsBehavior.$inject = [ 'canvas', 'injector' ];
22934
var RootElementsModule = {
 __init__: [ 'rootElementsBehavior' ],
 rootElementsBehavior: [ 'type', RootElementsBehavior ]
};
22939
var css_escape = {exports: {}};
22941
/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
22943
(function (module, exports) {
(function(root, factory) {
// https://github.com/umdjs/umd/blob/master/returnExports.js
{
	// For Node.js.
	module.exports = factory(root);
}
}(typeof commonjsGlobal != 'undefined' ? commonjsGlobal : commonjsGlobal, function(root) {
22952
if (root.CSS && root.CSS.escape) {
	return root.CSS.escape;
}
22956
// https://drafts.csswg.org/cssom/#serialize-an-identifier
var cssEscape = function(value) {
	if (arguments.length == 0) {
		throw new TypeError('`CSS.escape` requires an argument.');
	}
	var string = String(value);
	var length = string.length;
	var index = -1;
	var codeUnit;
	var result = '';
	var firstCodeUnit = string.charCodeAt(0);
	while (++index < length) {
		codeUnit = string.charCodeAt(index);
		// Note: there’s no need to special-case astral symbols, surrogate
		// pairs, or lone surrogates.
22972
		// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
		// (U+FFFD).
		if (codeUnit == 0x0000) {
			result += '\uFFFD';
			continue;
		}
22979
		if (
			// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
			// U+007F, […]
			(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
			// If the character is the first character and is in the range [0-9]
			// (U+0030 to U+0039), […]
			(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
			// If the character is the second character and is in the range [0-9]
			// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
			(
				index == 1 &&
				codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
				firstCodeUnit == 0x002D
			)
		) {
			// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
			result += '\\' + codeUnit.toString(16) + ' ';
			continue;
		}
22999
		if (
			// If the character is the first character and is a `-` (U+002D), and
			// there is no second character, […]
			index == 0 &&
			length == 1 &&
			codeUnit == 0x002D
		) {
			result += '\\' + string.charAt(index);
			continue;
		}
23010
		// If the character is not handled by one of the above rules and is
		// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
		// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
		// U+005A), or [a-z] (U+0061 to U+007A), […]
		if (
			codeUnit >= 0x0080 ||
			codeUnit == 0x002D ||
			codeUnit == 0x005F ||
			codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
			codeUnit >= 0x0041 && codeUnit <= 0x005A ||
			codeUnit >= 0x0061 && codeUnit <= 0x007A
		) {
			// the character itself
			result += string.charAt(index);
			continue;
		}
23027
		// Otherwise, the escaped character.
		// https://drafts.csswg.org/cssom/#escape-a-character
		result += '\\' + string.charAt(index);
23031
	}
	return result;
};
23035
if (!root.CSS) {
	root.CSS = {};
}
23039
root.CSS.escape = cssEscape;
return cssEscape;
23042
}));
}(css_escape));
23045
var cssEscape = css_escape.exports;
23047
var HTML_ESCAPE_MAP = {
 '&': '&amp;',
 '<': '&lt;',
 '>': '&gt;',
 '"': '&quot;',
 '\'': '&#39;'
};
23055
function escapeHTML(str) {
 str = '' + str;
23058
 return str && str.replace(/[&<>"']/g, function(match) {
   return HTML_ESCAPE_MAP[match];
 });
}
23063
var planeSuffix = '_plane';
23065
/**
* Get primary shape ID for a plane.
*
* @param  {djs.model.Base|ModdleElement} element
*
* @returns {String}
*/
function getShapeIdFromPlane(element) {
 var id = element.id;
23075
 return removePlaneSuffix(id);
}
23078
/**
* Get plane ID for a primary shape.
*
* @param  {djs.model.Base|ModdleElement} element
*
* @returns {String}
*/
function getPlaneIdFromShape(element) {
 var id = element.id;
23088
 if (is$1(element, 'bpmn:SubProcess')) {
   return addPlaneSuffix(id);
 }
23092
 return id;
}
23095
/**
* Get plane ID for primary shape ID.
*
* @param {String} id
*
* @returns {String}
*/
function toPlaneId(id) {
 return addPlaneSuffix(id);
}
23106
/**
* Check wether element is plane.
*
* @param  {djs.model.Base|ModdleElement} element
*
* @returns {Boolean}
*/
function isPlane(element) {
 var di = getDi(element);
23116
 return is$1(di, 'bpmndi:BPMNPlane');
}
23119
function addPlaneSuffix(id) {
 return id + planeSuffix;
}
23123
function removePlaneSuffix(id) {
 return id.replace(new RegExp(planeSuffix + '$'), '');
}
23127
var OPEN_CLASS = 'bjs-breadcrumbs-shown';
23129
23130
/**
* Adds overlays that allow switching planes on collapsed subprocesses.
*
* @param {eventBus} eventBus
* @param {elementRegistry} elementRegistry
* @param {overlays} overlays
* @param {canvas} canvas
*/
function DrilldownBreadcrumbs(eventBus, elementRegistry, overlays, canvas) {
 var breadcrumbs = domify$1('<ul class="bjs-breadcrumbs"></ul>');
 var container = canvas.getContainer();
 var containerClasses = classes$2(container);
 container.appendChild(breadcrumbs);
23144
 var boParents = [];
23146
 // update breadcrumbs if name or ID of the primary shape changes
 eventBus.on('element.changed', function(e) {
   var shape = e.element,
       bo = getBusinessObject(shape);
23151
   var isPresent = find(boParents, function(el) {
     return el === bo;
   });
23155
   if (!isPresent) {
     return;
   }
23159
   updateBreadcrumbs();
 });
23162
 /**
  * Updates the displayed breadcrumbs. If no element is provided, only the
  * labels are updated.
  *
  * @param {djs.model.Base} [element]
  */
 function updateBreadcrumbs(element) {
   if (element) {
     boParents = getBoParentChain(element);
   }
23173
   var path = boParents.map(function(parent) {
     var title = escapeHTML(parent.name || parent.id);
     var link = domify$1('<li><span class="bjs-crumb"><a title="' + title + '">' + title + '</a></span></li>');
23177
     var parentPlane = canvas.findRoot(getPlaneIdFromShape(parent)) || canvas.findRoot(parent.id);
23179
     // when the root is a collaboration, the process does not have a corresponding
     // element in the elementRegisty. Instead, we search for the corresponding participant
     if (!parentPlane && is$1(parent, 'bpmn:Process')) {
       var participant = elementRegistry.find(function(element) {
         var bo = getBusinessObject(element);
         return bo && bo.processRef && bo.processRef === parent;
       });
23187
       parentPlane = canvas.findRoot(participant.id);
     }
23190
     link.addEventListener('click', function() {
       canvas.setRootElement(parentPlane);
     });
23194
     return link;
   });
23197
   breadcrumbs.innerHTML = '';
23199
   // show breadcrumbs and expose state to .djs-container
   var visible = path.length > 1;
   containerClasses.toggle(OPEN_CLASS, visible);
23203
   path.forEach(function(el) {
     breadcrumbs.appendChild(el);
   });
 }
23208
 eventBus.on('root.set', function(event) {
   updateBreadcrumbs(event.element);
 });
23212
}
23214
DrilldownBreadcrumbs.$inject = [ 'eventBus', 'elementRegistry', 'overlays', 'canvas' ];
23216
23217
// helpers //////////
23219
/**
* Returns the parents for the element using the business object chain,
* starting with the root element.
*
* @param {djs.model.Shape} child
*
* @returns {Array<djs.model.Shape>} parents
*/
function getBoParentChain(child) {
 var bo = getBusinessObject(child);
23230
 var parents = [];
23232
 for (var element = bo; element; element = element.$parent) {
   if (is$1(element, 'bpmn:SubProcess') || is$1(element, 'bpmn:Process')) {
     parents.push(element);
   }
 }
23238
 return parents.reverse();
}
23241
/**
* Move collapsed subprocesses into view when drilling down.
*
* Zoom and scroll are saved in a session.
*
* @param {eventBus} eventBus
* @param {canvas} canvas
*/
function DrilldownCentering(eventBus, canvas) {
23251
 var currentRoot = null;
 var positionMap = new Map();
23254
 eventBus.on('root.set', function(event) {
   var newRoot = event.element;
   var currentViewbox = canvas.viewbox();
   var storedViewbox = positionMap.get(newRoot);
23259
   positionMap.set(currentRoot, {
     x: currentViewbox.x,
     y: currentViewbox.y,
     zoom: currentViewbox.scale
   });
23265
   currentRoot = newRoot;
23267
   // current root was replaced with a collaboration, we don't update the viewbox
   if (is$1(newRoot, 'bpmn:Collaboration') && !storedViewbox) {
     return;
   }
23272
   storedViewbox = storedViewbox || { x: 0, y: 0, zoom: 1 };
23274
   var dx = (currentViewbox.x - storedViewbox.x) * currentViewbox.scale,
       dy = (currentViewbox.y - storedViewbox.y) * currentViewbox.scale;
23277
   if (dx !== 0 || dy !== 0) {
     canvas.scroll({
       dx: dx,
       dy: dy
     });
   }
23284
   if (storedViewbox.zoom !== currentViewbox.scale) {
     canvas.zoom(storedViewbox.zoom, { x: 0, y: 0 });
   }
 });
23289
 eventBus.on('diagram.clear', function() {
   positionMap.clear();
   currentRoot = null;
 });
23294
}
23296
DrilldownCentering.$inject = [ 'eventBus', 'canvas' ];
23298
23299
/**
* ES5 Map implementation. Works.
*/
function Map() {
23304
 this._entries = [];
23306
 this.set = function(key, value) {
23308
   var found = false;
23310
   for (var k in this._entries) {
     if (this._entries[k][0] === key) {
       this._entries[k][1] = value;
23314
       found = true;
23316
       break;
     }
   }
23320
   if (!found) {
     this._entries.push([ key, value ]);
   }
 };
23325
 this.get = function(key) {
23327
   for (var k in this._entries) {
     if (this._entries[k][0] === key) {
       return this._entries[k][1];
     }
   }
23333
   return null;
 };
23336
 this.clear = function() {
   this._entries.length = 0;
 };
23340
 this.remove = function(key) {
23342
   var idx = -1;
23344
   for (var k in this._entries) {
     if (this._entries[k][0] === key) {
       idx = k;
23348
       break;
     }
   }
23352
   if (idx !== -1) {
     this._entries.splice(idx, 1);
   }
 };
}
23358
var DEFAULT_POSITION$1 = {
 x: 180,
 y: 160
};
23363
/**
* Hook into `import.render.start` and create new planes for diagrams with
* collapsed subprocesses and all dis on the same plane.
*
* @param {eventBus} eventBus
* @param {moddle} moddle
*/
function SubprocessCompatibility(eventBus, moddle) {
 this._eventBus = eventBus;
 this._moddle = moddle;
23374
 var self = this;
23376
 eventBus.on('import.render.start', 1500, function(e, context) {
   self.handleImport(context.definitions);
 });
}
23381
SubprocessCompatibility.prototype.handleImport = function(definitions) {
 if (!definitions.diagrams) {
   return;
 }
23386
 var self = this;
 this._definitions = definitions;
 this._processToDiagramMap = {};
23390
 definitions.diagrams.forEach(function(diagram) {
   if (!diagram.plane || !diagram.plane.bpmnElement) {
     return;
   }
23395
   self._processToDiagramMap[diagram.plane.bpmnElement.id] = diagram;
 });
23398
 var newDiagrams = [];
 definitions.diagrams.forEach(function(diagram) {
   var createdDiagrams = self.createNewDiagrams(diagram.plane);
   Array.prototype.push.apply(newDiagrams, createdDiagrams);
 });
23404
 newDiagrams.forEach(function(diagram) {
   self.movePlaneElementsToOrigin(diagram.plane);
 });
};
23409
23410
/**
* Moves all DI elements from collapsed subprocesses to a new plane.
*
* @param {Object} plane
* @return {Array} new diagrams created for the collapsed subprocesses
*/
SubprocessCompatibility.prototype.createNewDiagrams = function(plane) {
 var self = this;
23419
 var collapsedElements = [];
 var elementsToMove = [];
23422
 plane.get('planeElement').forEach(function(diElement) {
   var bo = diElement.bpmnElement;
23425
   if (!bo) {
     return;
   }
23429
   var parent = bo.$parent;
23431
   if (is$1(bo, 'bpmn:SubProcess') && !diElement.isExpanded) {
     collapsedElements.push(bo);
   }
23435
   if (shouldMoveToPlane(bo, plane)) {
23437
     // don't change the array while we iterate over it
     elementsToMove.push({ diElement: diElement, parent: parent });
   }
 });
23442
 var newDiagrams = [];
23444
 // create new planes for all collapsed subprocesses, even when they are empty
 collapsedElements.forEach(function(element) {
   if (!self._processToDiagramMap[element.id]) {
     var diagram = self.createDiagram(element);
     self._processToDiagramMap[element.id] = diagram;
     newDiagrams.push(diagram);
   }
 });
23453
 elementsToMove.forEach(function(element) {
   var diElement = element.diElement;
   var parent = element.parent;
23457
   // parent is expanded, get nearest collapsed parent
   while (parent && collapsedElements.indexOf(parent) === -1) {
     parent = parent.$parent;
   }
23462
   // false positive, all parents are expanded
   if (!parent) {
     return;
   }
23467
   var diagram = self._processToDiagramMap[parent.id];
   self.moveToDiPlane(diElement, diagram.plane);
 });
23471
 return newDiagrams;
};
23474
SubprocessCompatibility.prototype.movePlaneElementsToOrigin = function(plane) {
 var elements = plane.get('planeElement');
23477
 // get bounding box of all elements
 var planeBounds = getPlaneBounds(plane);
23480
 var offset = {
   x: planeBounds.x - DEFAULT_POSITION$1.x,
   y: planeBounds.y - DEFAULT_POSITION$1.y
 };
23485
 elements.forEach(function(diElement) {
   if (diElement.waypoint) {
     diElement.waypoint.forEach(function(waypoint) {
       waypoint.x = waypoint.x - offset.x;
       waypoint.y = waypoint.y - offset.y;
     });
   } else if (diElement.bounds) {
     diElement.bounds.x = diElement.bounds.x - offset.x;
     diElement.bounds.y = diElement.bounds.y - offset.y;
   }
 });
};
23498
23499
SubprocessCompatibility.prototype.moveToDiPlane = function(diElement, newPlane) {
 var containingDiagram = findRootDiagram(diElement);
23502
 // remove DI from old Plane and add it to the new one
 var parentPlaneElement = containingDiagram.plane.get('planeElement');
 parentPlaneElement.splice(parentPlaneElement.indexOf(diElement), 1);
 newPlane.get('planeElement').push(diElement);
};
23508
23509
SubprocessCompatibility.prototype.createDiagram = function(bo) {
 var plane = this._moddle.create('bpmndi:BPMNPlane', { bpmnElement: bo });
 var diagram = this._moddle.create('bpmndi:BPMNDiagram', {
   plane: plane
 });
 plane.$parent = diagram;
 plane.bpmnElement = bo;
 diagram.$parent = this._definitions;
 this._definitions.diagrams.push(diagram);
 return diagram;
};
23521
SubprocessCompatibility.$inject = [ 'eventBus', 'moddle' ];
23523
23524
// helpers //////////////////////////
23526
function findRootDiagram(element) {
 if (is$1(element, 'bpmndi:BPMNDiagram')) {
   return element;
 } else {
   return findRootDiagram(element.$parent);
 }
}
23534
function getPlaneBounds(plane) {
 var planeTrbl = {
   top: Infinity,
   right: -Infinity,
   bottom: -Infinity,
   left: Infinity
 };
23542
 plane.planeElement.forEach(function(element) {
   if (!element.bounds) {
     return;
   }
23547
   var trbl = asTRBL(element.bounds);
23549
   planeTrbl.top = Math.min(trbl.top, planeTrbl.top);
   planeTrbl.left = Math.min(trbl.left, planeTrbl.left);
 });
23553
 return asBounds(planeTrbl);
}
23556
function shouldMoveToPlane(bo, plane) {
 var parent = bo.$parent;
23559
 // don't move elements that are already on the plane
 if (!is$1(parent, 'bpmn:SubProcess') || parent === plane.bpmnElement) {
   return false;
 }
23564
 // dataAssociations are children of the subprocess but rendered on process level
 // cf. https://github.com/bpmn-io/bpmn-js/issues/1619
 if (isAny(bo, ['bpmn:DataInputAssociation', 'bpmn:DataOutputAssociation'])) {
   return false;
 }
23570
 return true;
}
23573
var LOW_PRIORITY$l = 250;
var ARROW_DOWN_SVG = '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M4.81801948,3.50735931 L10.4996894,9.1896894 L10.5,4 L12,4 L12,12 L4,12 L4,10.5 L9.6896894,10.4996894 L3.75735931,4.56801948 C3.46446609,4.27512627 3.46446609,3.80025253 3.75735931,3.50735931 C4.05025253,3.21446609 4.52512627,3.21446609 4.81801948,3.50735931 Z"/></svg>';
23576
var EMPTY_MARKER = 'bjs-drilldown-empty';
23578
function DrilldownOverlayBehavior(
   canvas, eventBus, elementRegistry, overlays
) {
 CommandInterceptor.call(this, eventBus);
23583
 this._canvas = canvas;
 this._eventBus = eventBus;
 this._elementRegistry = elementRegistry;
 this._overlays = overlays;
23588
 var self = this;
23590
 this.executed('shape.toggleCollapse', LOW_PRIORITY$l, function(context) {
   var shape = context.shape;
23593
   // Add overlay to the collapsed shape
   if (self.canDrillDown(shape)) {
     self.addOverlay(shape);
   } else {
     self.removeOverlay(shape);
   }
 }, true);
23601
23602
 this.reverted('shape.toggleCollapse', LOW_PRIORITY$l, function(context) {
   var shape = context.shape;
23605
   // Add overlay to the collapsed shape
   if (self.canDrillDown(shape)) {
     self.addOverlay(shape);
   } else {
     self.removeOverlay(shape);
   }
 }, true);
23613
23614
 this.executed(['shape.create', 'shape.move', 'shape.delete'], LOW_PRIORITY$l,
   function(context) {
     var oldParent = context.oldParent,
         newParent = context.newParent || context.parent,
         shape = context.shape;
23620
     // Add overlay to the collapsed shape
     if (self.canDrillDown(shape)) {
       self.addOverlay(shape);
     }
23625
     self.updateDrilldownOverlay(oldParent);
     self.updateDrilldownOverlay(newParent);
     self.updateDrilldownOverlay(shape);
   }, true);
23630
23631
 this.reverted(['shape.create', 'shape.move', 'shape.delete'], LOW_PRIORITY$l,
   function(context) {
     var oldParent = context.oldParent,
         newParent = context.newParent || context.parent,
         shape = context.shape;
23637
     // Add overlay to the collapsed shape
     if (self.canDrillDown(shape)) {
       self.addOverlay(shape);
     }
23642
     self.updateDrilldownOverlay(oldParent);
     self.updateDrilldownOverlay(newParent);
     self.updateDrilldownOverlay(shape);
   }, true);
23647
23648
 eventBus.on('import.render.complete', function() {
   elementRegistry.filter(function(e) {
     return self.canDrillDown(e);
   }).map(function(el) {
     self.addOverlay(el);
   });
 });
23656
}
23658
inherits$1(DrilldownOverlayBehavior, CommandInterceptor);
23660
DrilldownOverlayBehavior.prototype.updateDrilldownOverlay = function(shape) {
 var canvas = this._canvas;
23663
 if (!shape) {
   return;
 }
23667
 var root = canvas.findRoot(shape);
 if (root) {
   this.updateOverlayVisibility(root);
 }
};
23673
23674
DrilldownOverlayBehavior.prototype.canDrillDown = function(element) {
 var canvas = this._canvas;
 return is$1(element, 'bpmn:SubProcess') && canvas.findRoot(getPlaneIdFromShape(element));
};
23679
/**
* Updates visibility of the drilldown overlay. If the plane has no elements,
* the drilldown will be only shown when the element is selected.
*
* @param {djs.model.Shape|djs.model.Root} element collapsed shape or root element
*/
DrilldownOverlayBehavior.prototype.updateOverlayVisibility = function(element) {
 var overlays = this._overlays;
23688
 var bo = element.businessObject;
23690
 var overlay = overlays.get({ element: bo.id, type: 'drilldown' })[0];
23692
 if (!overlay) {
   return;
 }
23696
 var hasContent = bo && bo.flowElements && bo.flowElements.length;
 classes$2(overlay.html).toggle(EMPTY_MARKER, !hasContent);
};
23700
/**
* Attaches a drilldown button to the given element. We assume that the plane has
* the same id as the element.
*
* @param {djs.model.Shape} element collapsed shape
*/
DrilldownOverlayBehavior.prototype.addOverlay = function(element) {
 var canvas = this._canvas;
 var overlays = this._overlays;
23710
 var existingOverlays = overlays.get({ element: element, type: 'drilldown' });
 if (existingOverlays.length) {
   this.removeOverlay(element);
 }
23715
 var button = domify$1('<button class="bjs-drilldown">' + ARROW_DOWN_SVG + '</button>');
23717
 button.addEventListener('click', function() {
   canvas.setRootElement(canvas.findRoot(getPlaneIdFromShape(element)));
 });
23721
 overlays.add(element, 'drilldown', {
   position: {
     bottom: -7,
     right: -8
   },
   html: button
 });
23729
 this.updateOverlayVisibility(element);
};
23732
DrilldownOverlayBehavior.prototype.removeOverlay = function(element) {
 var overlays = this._overlays;
23735
 overlays.remove({
   element: element,
   type: 'drilldown'
 });
};
23741
DrilldownOverlayBehavior.$inject = [
 'canvas',
 'eventBus',
 'elementRegistry',
 'overlays'
];
23748
var DrilldownModdule = {
 __depends__: [ OverlaysModule, ChangeSupportModule, RootElementsModule ],
 __init__: [ 'drilldownBreadcrumbs', 'drilldownOverlayBehavior', 'drilldownCentering', 'subprocessCompatibility'],
 drilldownBreadcrumbs: [ 'type', DrilldownBreadcrumbs ],
 drilldownCentering: [ 'type', DrilldownCentering ],
 drilldownOverlayBehavior: [ 'type', DrilldownOverlayBehavior ],
 subprocessCompatibility: [ 'type', SubprocessCompatibility ]
};
23757
/**
* A viewer for BPMN 2.0 diagrams.
*
* Have a look at {@link NavigatedViewer} or {@link Modeler} for bundles that include
* additional features.
*
*
* ## Extending the Viewer
*
* In order to extend the viewer pass extension modules to bootstrap via the
* `additionalModules` option. An extension module is an object that exposes
* named services.
*
* The following example depicts the integration of a simple
* logging component that integrates with interaction events:
*
*
* ```javascript
*
* // logging component
* function InteractionLogger(eventBus) {
*   eventBus.on('element.hover', function(event) {
*     console.log()
*   })
* }
*
* InteractionLogger.$inject = [ 'eventBus' ]; // minification save
*
* // extension module
* var extensionModule = {
*   __init__: [ 'interactionLogger' ],
*   interactionLogger: [ 'type', InteractionLogger ]
* };
*
* // extend the viewer
* var bpmnViewer = new Viewer({ additionalModules: [ extensionModule ] });
* bpmnViewer.importXML(...);
* ```
*
* @param {Object} [options] configuration options to pass to the viewer
* @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.
* @param {string|number} [options.width] the width of the viewer
* @param {string|number} [options.height] the height of the viewer
* @param {Object} [options.moddleExtensions] extension packages to provide
* @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules
* @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules
*/
function Viewer(options) {
 BaseViewer.call(this, options);
}
23808
inherits$1(Viewer, BaseViewer);
23810
// modules the viewer is composed of
Viewer.prototype._modules = [
 CoreModule,
 translate,
 SelectionModule,
 OverlaysModule,
 DrilldownModdule
];
23819
// default moddle extensions the viewer is composed of
Viewer.prototype._moddleExtensions = {};
23822
/**
* Returns true if event was triggered with any modifier
* @param {KeyboardEvent} event
*/
function hasModifier(event) {
 return (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey);
}
23830
/**
* @param {KeyboardEvent} event
*/
function isCmd(event) {
23835
 // ensure we don't react to AltGr
 // (mapped to CTRL + ALT)
 if (event.altKey) {
   return false;
 }
23841
 return event.ctrlKey || event.metaKey;
}
23844
/**
* Checks if key pressed is one of provided keys.
*
* @param {string|Array<string>} keys
* @param {KeyboardEvent} event
*/
function isKey(keys, event) {
 keys = isArray$4(keys) ? keys : [ keys ];
23853
 return keys.indexOf(event.key) !== -1 || keys.indexOf(event.keyCode) !== -1;
}
23856
/**
* @param {KeyboardEvent} event
*/
function isShift(event) {
 return event.shiftKey;
}
23863
var KEYDOWN_EVENT = 'keyboard.keydown',
   KEYUP_EVENT = 'keyboard.keyup';
23866
var HANDLE_MODIFIER_ATTRIBUTE = 'input-handle-modified-keys';
23868
var DEFAULT_PRIORITY$3 = 1000;
23870
/**
* A keyboard abstraction that may be activated and
* deactivated by users at will, consuming key events
* and triggering diagram actions.
*
* For keys pressed down, keyboard fires `keyboard.keydown` event.
* The event context contains one field which is `KeyboardEvent` event.
*
* The implementation fires the following key events that allow
* other components to hook into key handling:
*
*  - keyboard.bind
*  - keyboard.unbind
*  - keyboard.init
*  - keyboard.destroy
*
* All events contain one field which is node.
*
* A default binding for the keyboard may be specified via the
* `keyboard.bindTo` configuration option.
*
* @param {Config} config
* @param {EventBus} eventBus
*/
function Keyboard(config, eventBus) {
 var self = this;
23897
 this._config = config || {};
 this._eventBus = eventBus;
23900
 this._keydownHandler = this._keydownHandler.bind(this);
 this._keyupHandler = this._keyupHandler.bind(this);
23903
 // properly clean dom registrations
 eventBus.on('diagram.destroy', function() {
   self._fire('destroy');
23907
   self.unbind();
 });
23910
 eventBus.on('diagram.init', function() {
   self._fire('init');
 });
23914
 eventBus.on('attach', function() {
   if (config && config.bindTo) {
     self.bind(config.bindTo);
   }
 });
23920
 eventBus.on('detach', function() {
   self.unbind();
 });
}
23925
Keyboard.$inject = [
 'config.keyboard',
 'eventBus'
];
23930
Keyboard.prototype._keydownHandler = function(event) {
 this._keyHandler(event, KEYDOWN_EVENT);
};
23934
Keyboard.prototype._keyupHandler = function(event) {
 this._keyHandler(event, KEYUP_EVENT);
};
23938
Keyboard.prototype._keyHandler = function(event, type) {
 var eventBusResult;
23941
 if (this._isEventIgnored(event)) {
   return;
 }
23945
 var context = {
   keyEvent: event
 };
23949
 eventBusResult = this._eventBus.fire(type || KEYDOWN_EVENT, context);
23951
 if (eventBusResult) {
   event.preventDefault();
 }
};
23956
Keyboard.prototype._isEventIgnored = function(event) {
 return isInput(event.target) && this._isModifiedKeyIgnored(event);
};
23960
Keyboard.prototype._isModifiedKeyIgnored = function(event) {
 if (!isCmd(event)) {
   return true;
 }
23965
 var allowedModifiers = this._getAllowedModifiers(event.target);
 return allowedModifiers.indexOf(event.key) === -1;
};
23969
Keyboard.prototype._getAllowedModifiers = function(element) {
 var modifierContainer = closest(element, '[' + HANDLE_MODIFIER_ATTRIBUTE + ']', true);
23972
 if (!modifierContainer || (this._node && !this._node.contains(modifierContainer))) {
   return [];
 }
23976
 return modifierContainer.getAttribute(HANDLE_MODIFIER_ATTRIBUTE).split(',');
};
23979
Keyboard.prototype.bind = function(node) {
23981
 // make sure that the keyboard is only bound once to the DOM
 this.unbind();
23984
 this._node = node;
23986
 // bind key events
 componentEvent.bind(node, 'keydown', this._keydownHandler, true);
 componentEvent.bind(node, 'keyup', this._keyupHandler, true);
23990
 this._fire('bind');
};
23993
Keyboard.prototype.getBinding = function() {
 return this._node;
};
23997
Keyboard.prototype.unbind = function() {
 var node = this._node;
24000
 if (node) {
   this._fire('unbind');
24003
   // unbind key events
   componentEvent.unbind(node, 'keydown', this._keydownHandler, true);
   componentEvent.unbind(node, 'keyup', this._keyupHandler, true);
 }
24008
 this._node = null;
};
24011
Keyboard.prototype._fire = function(event) {
 this._eventBus.fire('keyboard.' + event, { node: this._node });
};
24015
/**
* Add a listener function that is notified with `KeyboardEvent` whenever
* the keyboard is bound and the user presses a key. If no priority is
* provided, the default value of 1000 is used.
*
* @param {number} [priority]
* @param {Function} listener
* @param {string} type
*/
Keyboard.prototype.addListener = function(priority, listener, type) {
 if (isFunction(priority)) {
   type = listener;
   listener = priority;
   priority = DEFAULT_PRIORITY$3;
 }
24031
 this._eventBus.on(type || KEYDOWN_EVENT, priority, listener);
};
24034
Keyboard.prototype.removeListener = function(listener, type) {
 this._eventBus.off(type || KEYDOWN_EVENT, listener);
};
24038
Keyboard.prototype.hasModifier = hasModifier;
Keyboard.prototype.isCmd = isCmd;
Keyboard.prototype.isShift = isShift;
Keyboard.prototype.isKey = isKey;
24043
24044
24045
// helpers ///////
24047
function isInput(target) {
 return target && (matchesSelector(target, 'input, textarea') || target.contentEditable === 'true');
}
24051
var LOW_PRIORITY$k = 500;
24053
var KEYCODE_C = 67;
var KEYCODE_V = 86;
var KEYCODE_Y = 89;
var KEYCODE_Z = 90;
24058
var KEYS_COPY = [ 'c', 'C', KEYCODE_C ];
var KEYS_PASTE = [ 'v', 'V', KEYCODE_V ];
var KEYS_REDO = [ 'y', 'Y', KEYCODE_Y ];
var KEYS_UNDO = [ 'z', 'Z', KEYCODE_Z ];
24063
24064
/**
* Adds default keyboard bindings.
*
* This does not pull in any features will bind only actions that
* have previously been registered against the editorActions component.
*
* @param {EventBus} eventBus
* @param {Keyboard} keyboard
*/
function KeyboardBindings(eventBus, keyboard) {
24075
 var self = this;
24077
 eventBus.on('editorActions.init', LOW_PRIORITY$k, function(event) {
24079
   var editorActions = event.editorActions;
24081
   self.registerBindings(keyboard, editorActions);
 });
}
24085
KeyboardBindings.$inject = [
 'eventBus',
 'keyboard'
];
24090
24091
/**
* Register available keyboard bindings.
*
* @param {Keyboard} keyboard
* @param {EditorActions} editorActions
*/
KeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {
24099
 /**
  * Add keyboard binding if respective editor action
  * is registered.
  *
  * @param {string} action name
  * @param {Function} fn that implements the key binding
  */
 function addListener(action, fn) {
24108
   if (editorActions.isRegistered(action)) {
     keyboard.addListener(fn);
   }
 }
24113
24114
 // undo
 // (CTRL|CMD) + Z
 addListener('undo', function(context) {
24118
   var event = context.keyEvent;
24120
   if (isCmd(event) && !isShift(event) && isKey(KEYS_UNDO, event)) {
     editorActions.trigger('undo');
24123
     return true;
   }
 });
24127
 // redo
 // CTRL + Y
 // CMD + SHIFT + Z
 addListener('redo', function(context) {
24132
   var event = context.keyEvent;
24134
   if (isCmd(event) && (isKey(KEYS_REDO, event) || (isKey(KEYS_UNDO, event) && isShift(event)))) {
     editorActions.trigger('redo');
24137
     return true;
   }
 });
24141
 // copy
 // CTRL/CMD + C
 addListener('copy', function(context) {
24145
   var event = context.keyEvent;
24147
   if (isCmd(event) && isKey(KEYS_COPY, event)) {
     editorActions.trigger('copy');
24150
     return true;
   }
 });
24154
 // paste
 // CTRL/CMD + V
 addListener('paste', function(context) {
24158
   var event = context.keyEvent;
24160
   if (isCmd(event) && isKey(KEYS_PASTE, event)) {
     editorActions.trigger('paste');
24163
     return true;
   }
 });
24167
 // zoom in one step
 // CTRL/CMD + +
 addListener('stepZoom', function(context) {
24171
   var event = context.keyEvent;
24173
   // quirk: it has to be triggered by `=` as well to work on international keyboard layout
   // cf: https://github.com/bpmn-io/bpmn-js/issues/1362#issuecomment-722989754
   if (isKey([ '+', 'Add', '=' ], event) && isCmd(event)) {
     editorActions.trigger('stepZoom', { value: 1 });
24178
     return true;
   }
 });
24182
 // zoom out one step
 // CTRL + -
 addListener('stepZoom', function(context) {
24186
   var event = context.keyEvent;
24188
   if (isKey([ '-', 'Subtract' ], event) && isCmd(event)) {
     editorActions.trigger('stepZoom', { value: -1 });
24191
     return true;
   }
 });
24195
 // zoom to the default level
 // CTRL + 0
 addListener('zoom', function(context) {
24199
   var event = context.keyEvent;
24201
   if (isKey('0', event) && isCmd(event)) {
     editorActions.trigger('zoom', { value: 1 });
24204
     return true;
   }
 });
24208
 // delete selected element
 // DEL
 addListener('removeSelection', function(context) {
24212
   var event = context.keyEvent;
24214
   if (isKey([ 'Backspace', 'Delete', 'Del' ], event)) {
     editorActions.trigger('removeSelection');
24217
     return true;
   }
 });
};
24222
var KeyboardModule$1 = {
 __init__: [ 'keyboard', 'keyboardBindings' ],
 keyboard: [ 'type', Keyboard ],
 keyboardBindings: [ 'type', KeyboardBindings ]
};
24228
var DEFAULT_CONFIG$1 = {
 moveSpeed: 50,
 moveSpeedAccelerated: 200
};
24233
24234
/**
* A feature that allows users to move the canvas using the keyboard.
*
* @param {Object} config
* @param {number} [config.moveSpeed=50]
* @param {number} [config.moveSpeedAccelerated=200]
* @param {Keyboard} keyboard
* @param {Canvas} canvas
*/
function KeyboardMove(
   config,
   keyboard,
   canvas
) {
24249
 var self = this;
24251
 this._config = assign({}, DEFAULT_CONFIG$1, config || {});
24253
 keyboard.addListener(arrowsListener);
24255
24256
 function arrowsListener(context) {
24258
   var event = context.keyEvent,
       config = self._config;
24261
   if (!keyboard.isCmd(event)) {
     return;
   }
24265
   if (keyboard.isKey([
     'ArrowLeft', 'Left',
     'ArrowUp', 'Up',
     'ArrowDown', 'Down',
     'ArrowRight', 'Right'
   ], event)) {
24272
     var speed = (
       keyboard.isShift(event) ?
         config.moveSpeedAccelerated :
         config.moveSpeed
     );
24278
     var direction;
24280
     switch (event.key) {
     case 'ArrowLeft':
     case 'Left':
       direction = 'left';
       break;
     case 'ArrowUp':
     case 'Up':
       direction = 'up';
       break;
     case 'ArrowRight':
     case 'Right':
       direction = 'right';
       break;
     case 'ArrowDown':
     case 'Down':
       direction = 'down';
       break;
     }
24299
     self.moveCanvas({
       speed: speed,
       direction: direction
     });
24304
     return true;
   }
 }
24308
 this.moveCanvas = function(opts) {
24310
   var dx = 0,
       dy = 0,
       speed = opts.speed;
24314
   var actualSpeed = speed / Math.min(Math.sqrt(canvas.viewbox().scale), 1);
24316
   switch (opts.direction) {
   case 'left': // Left
     dx = actualSpeed;
     break;
   case 'up': // Up
     dy = actualSpeed;
     break;
   case 'right': // Right
     dx = -actualSpeed;
     break;
   case 'down': // Down
     dy = -actualSpeed;
     break;
   }
24331
   canvas.scroll({
     dx: dx,
     dy: dy
   });
 };
24337
}
24339
24340
KeyboardMove.$inject = [
 'config.keyboardMove',
 'keyboard',
 'canvas'
];
24346
var KeyboardMoveModule = {
 __depends__: [
   KeyboardModule$1
 ],
 __init__: [ 'keyboardMove' ],
 keyboardMove: [ 'type', KeyboardMove ]
};
24354
var CURSOR_CLS_PATTERN = /^djs-cursor-.*$/;
24356
24357
function set(mode) {
 var classes$1 = classes(document.body);
24360
 classes$1.removeMatching(CURSOR_CLS_PATTERN);
24362
 if (mode) {
   classes$1.add('djs-cursor-' + mode);
 }
}
24367
function unset() {
 set(null);
}
24371
var TRAP_PRIORITY = 5000;
24373
/**
* Installs a click trap that prevents a ghost click following a dragging operation.
*
* @return {Function} a function to immediately remove the installed trap.
*/
function install(eventBus, eventName) {
24380
 eventName = eventName || 'element.click';
24382
 function trap() {
   return false;
 }
24386
 eventBus.once(eventName, TRAP_PRIORITY, trap);
24388
 return function() {
   eventBus.off(eventName, trap);
 };
}
24393
function center(bounds) {
 return {
   x: bounds.x + (bounds.width / 2),
   y: bounds.y + (bounds.height / 2)
 };
}
24400
24401
function delta(a, b) {
 return {
   x: a.x - b.x,
   y: a.y - b.y
 };
}
24408
var THRESHOLD$1 = 15;
24410
24411
/**
* Move the canvas via mouse.
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
*/
function MoveCanvas(eventBus, canvas) {
24419
 var context;
24421
24422
 // listen for move on element mouse down;
 // allow others to hook into the event before us though
 // (dragging / element moving will do this)
 eventBus.on('element.mousedown', 500, function(e) {
   return handleStart(e.originalEvent);
 });
24429
24430
 function handleMove(event) {
24432
   var start = context.start,
       button = context.button,
       position = toPoint(event),
       delta$1 = delta(position, start);
24437
   if (!context.dragging && length(delta$1) > THRESHOLD$1) {
     context.dragging = true;
24440
     if (button === 0) {
       install(eventBus);
     }
24444
     set('grab');
   }
24447
   if (context.dragging) {
24449
     var lastPosition = context.last || context.start;
24451
     delta$1 = delta(position, lastPosition);
24453
     canvas.scroll({
       dx: delta$1.x,
       dy: delta$1.y
     });
24458
     context.last = position;
   }
24461
   // prevent select
   event.preventDefault();
 }
24465
24466
 function handleEnd(event) {
   componentEvent.unbind(document, 'mousemove', handleMove);
   componentEvent.unbind(document, 'mouseup', handleEnd);
24470
   context = null;
24472
   unset();
 }
24475
 function handleStart(event) {
24477
   // event is already handled by '.djs-draggable'
   if (closest(event.target, '.djs-draggable')) {
     return;
   }
24482
   var button = event.button;
24484
   // reject right mouse button or modifier key
   if (button >= 2 || event.ctrlKey || event.shiftKey || event.altKey) {
     return;
   }
24489
   context = {
     button: button,
     start: toPoint(event)
   };
24494
   componentEvent.bind(document, 'mousemove', handleMove);
   componentEvent.bind(document, 'mouseup', handleEnd);
24497
   // we've handled the event
   return true;
 }
24501
 this.isActive = function() {
   return !!context;
 };
24505
}
24507
24508
MoveCanvas.$inject = [
 'eventBus',
 'canvas'
];
24513
24514
24515
// helpers ///////
24517
function length(point) {
 return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
}
24521
var MoveCanvasModule = {
 __init__: [ 'moveCanvas' ],
 moveCanvas: [ 'type', MoveCanvas ]
};
24526
/**
* Get the logarithm of x with base 10
* @param  {Integer} value
*/
function log10(x) {
 return Math.log(x) / Math.log(10);
}
24534
/**
* Get step size for given range and number of steps.
*
* @param {Object} range
* @param {number} range.min
* @param {number} range.max
*/
function getStepSize(range, steps) {
24543
 var minLinearRange = log10(range.min),
     maxLinearRange = log10(range.max);
24546
 var absoluteLinearRange = Math.abs(minLinearRange) + Math.abs(maxLinearRange);
24548
 return absoluteLinearRange / steps;
}
24551
function cap(range, scale) {
 return Math.max(range.min, Math.min(range.max, scale));
}
24555
var sign = Math.sign || function(n) {
 return n >= 0 ? 1 : -1;
};
24559
var RANGE = { min: 0.2, max: 4 },
   NUM_STEPS = 10;
24562
var DELTA_THRESHOLD = 0.1;
24564
var DEFAULT_SCALE = 0.75;
24566
/**
* An implementation of zooming and scrolling within the
* {@link Canvas} via the mouse wheel.
*
* Mouse wheel zooming / scrolling may be disabled using
* the {@link toggle(enabled)} method.
*
* @param {Object} [config]
* @param {boolean} [config.enabled=true] default enabled state
* @param {number} [config.scale=.75] scroll sensivity
* @param {EventBus} eventBus
* @param {Canvas} canvas
*/
function ZoomScroll(config, eventBus, canvas) {
24581
 config = config || {};
24583
 this._enabled = false;
24585
 this._canvas = canvas;
 this._container = canvas._container;
24588
 this._handleWheel = bind(this._handleWheel, this);
24590
 this._totalDelta = 0;
 this._scale = config.scale || DEFAULT_SCALE;
24593
 var self = this;
24595
 eventBus.on('canvas.init', function(e) {
   self._init(config.enabled !== false);
 });
}
24600
ZoomScroll.$inject = [
 'config.zoomScroll',
 'eventBus',
 'canvas'
];
24606
ZoomScroll.prototype.scroll = function scroll(delta) {
 this._canvas.scroll(delta);
};
24610
24611
ZoomScroll.prototype.reset = function reset() {
 this._canvas.zoom('fit-viewport');
};
24615
/**
* Zoom depending on delta.
*
* @param {number} delta
* @param {Object} position
*/
ZoomScroll.prototype.zoom = function zoom(delta, position) {
24623
 // zoom with half the step size of stepZoom
 var stepSize = getStepSize(RANGE, NUM_STEPS * 2);
24626
 // add until threshold reached
 this._totalDelta += delta;
24629
 if (Math.abs(this._totalDelta) > DELTA_THRESHOLD) {
   this._zoom(delta, position, stepSize);
24632
   // reset
   this._totalDelta = 0;
 }
};
24637
24638
ZoomScroll.prototype._handleWheel = function handleWheel(event) {
24640
 // event is already handled by '.djs-scrollable'
 if (closest(event.target, '.djs-scrollable', true)) {
   return;
 }
24645
 var element = this._container;
24647
 event.preventDefault();
24649
 // pinch to zoom is mapped to wheel + ctrlKey = true
 // in modern browsers (!)
24652
 var isZoom = event.ctrlKey;
24654
 var isHorizontalScroll = event.shiftKey;
24656
 var factor = -1 * this._scale,
     delta;
24659
 if (isZoom) {
   factor *= event.deltaMode === 0 ? 0.020 : 0.32;
 } else {
   factor *= event.deltaMode === 0 ? 1.0 : 16.0;
 }
24665
 if (isZoom) {
   var elementRect = element.getBoundingClientRect();
24668
   var offset = {
     x: event.clientX - elementRect.left,
     y: event.clientY - elementRect.top
   };
24673
   delta = (
     Math.sqrt(
       Math.pow(event.deltaY, 2) +
       Math.pow(event.deltaX, 2)
     ) * sign(event.deltaY) * factor
   );
24680
   // zoom in relative to diagram {x,y} coordinates
   this.zoom(delta, offset);
 } else {
24684
   if (isHorizontalScroll) {
     delta = {
       dx: factor * event.deltaY,
       dy: 0
     };
   } else {
     delta = {
       dx: factor * event.deltaX,
       dy: factor * event.deltaY
     };
   }
24696
   this.scroll(delta);
 }
};
24700
/**
* Zoom with fixed step size.
*
* @param {number} delta - Zoom delta (1 for zooming in, -1 for out).
* @param {Object} position
*/
ZoomScroll.prototype.stepZoom = function stepZoom(delta, position) {
24708
 var stepSize = getStepSize(RANGE, NUM_STEPS);
24710
 this._zoom(delta, position, stepSize);
};
24713
24714
/**
* Zoom in/out given a step size.
*
* @param {number} delta
* @param {Object} position
* @param {number} stepSize
*/
ZoomScroll.prototype._zoom = function(delta, position, stepSize) {
 var canvas = this._canvas;
24724
 var direction = delta > 0 ? 1 : -1;
24726
 var currentLinearZoomLevel = log10(canvas.zoom());
24728
 // snap to a proximate zoom step
 var newLinearZoomLevel = Math.round(currentLinearZoomLevel / stepSize) * stepSize;
24731
 // increase or decrease one zoom step in the given direction
 newLinearZoomLevel += stepSize * direction;
24734
 // calculate the absolute logarithmic zoom level based on the linear zoom level
 // (e.g. 2 for an absolute x2 zoom)
 var newLogZoomLevel = Math.pow(10, newLinearZoomLevel);
24738
 canvas.zoom(cap(RANGE, newLogZoomLevel), position);
};
24741
24742
/**
* Toggle the zoom scroll ability via mouse wheel.
*
* @param  {boolean} [newEnabled] new enabled state
*/
ZoomScroll.prototype.toggle = function toggle(newEnabled) {
24749
 var element = this._container;
 var handleWheel = this._handleWheel;
24752
 var oldEnabled = this._enabled;
24754
 if (typeof newEnabled === 'undefined') {
   newEnabled = !oldEnabled;
 }
24758
 // only react on actual changes
 if (oldEnabled !== newEnabled) {
24761
   // add or remove wheel listener based on
   // changed enabled state
   componentEvent[newEnabled ? 'bind' : 'unbind'](element, 'wheel', handleWheel, false);
 }
24766
 this._enabled = newEnabled;
24768
 return newEnabled;
};
24771
24772
ZoomScroll.prototype._init = function(newEnabled) {
 this.toggle(newEnabled);
};
24776
var ZoomScrollModule = {
 __init__: [ 'zoomScroll' ],
 zoomScroll: [ 'type', ZoomScroll ]
};
24781
/**
* A viewer that includes mouse navigation facilities
*
* @param {Object} options
*/
function NavigatedViewer(options) {
 Viewer.call(this, options);
}
24790
inherits$1(NavigatedViewer, Viewer);
24792
24793
NavigatedViewer.prototype._navigationModules = [
 KeyboardMoveModule,
 MoveCanvasModule,
 ZoomScrollModule
];
24799
NavigatedViewer.prototype._modules = [].concat(
 Viewer.prototype._modules,
 NavigatedViewer.prototype._navigationModules
);
24804
var hammer = {exports: {}};
24806
/*! Hammer.JS - v2.0.7 - 2016-04-22
* http://hammerjs.github.io/
*
* Copyright (c) 2016 Jorik Tangelder;
* Licensed under the MIT license */
24812
(function (module) {
(function(window, document, exportName, undefined$1) {
24815
var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
var TEST_ELEMENT = document.createElement('div');
24818
var TYPE_FUNCTION = 'function';
24820
var round = Math.round;
var abs = Math.abs;
var now = Date.now;
24824
/**
* set a timeout with a given scope
* @param {Function} fn
* @param {Number} timeout
* @param {Object} context
* @returns {number}
*/
function setTimeoutContext(fn, timeout, context) {
   return setTimeout(bindFn(fn, context), timeout);
}
24835
/**
* if the argument is an array, we want to execute the fn on each entry
* if it aint an array we don't want to do a thing.
* this is used by all the methods that accept a single and array argument.
* @param {*|Array} arg
* @param {String} fn
* @param {Object} [context]
* @returns {Boolean}
*/
function invokeArrayArg(arg, fn, context) {
   if (Array.isArray(arg)) {
       each(arg, context[fn], context);
       return true;
   }
   return false;
}
24852
/**
* walk objects and arrays
* @param {Object} obj
* @param {Function} iterator
* @param {Object} context
*/
function each(obj, iterator, context) {
   var i;
24861
   if (!obj) {
       return;
   }
24865
   if (obj.forEach) {
       obj.forEach(iterator, context);
   } else if (obj.length !== undefined$1) {
       i = 0;
       while (i < obj.length) {
           iterator.call(context, obj[i], i, obj);
           i++;
       }
   } else {
       for (i in obj) {
           obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
       }
   }
}
24880
/**
* wrap a method with a deprecation warning and stack trace
* @param {Function} method
* @param {String} name
* @param {String} message
* @returns {Function} A new function wrapping the supplied method.
*/
function deprecate(method, name, message) {
   var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\n' + message + ' AT \n';
   return function() {
       var e = new Error('get-stack-trace');
       var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '')
           .replace(/^\s+at\s+/gm, '')
           .replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
24895
       var log = window.console && (window.console.warn || window.console.log);
       if (log) {
           log.call(window.console, deprecationMessage, stack);
       }
       return method.apply(this, arguments);
   };
}
24903
/**
* extend object.
* means that properties in dest will be overwritten by the ones in src.
* @param {Object} target
* @param {...Object} objects_to_assign
* @returns {Object} target
*/
var assign;
if (typeof Object.assign !== 'function') {
   assign = function assign(target) {
       if (target === undefined$1 || target === null) {
           throw new TypeError('Cannot convert undefined or null to object');
       }
24917
       var output = Object(target);
       for (var index = 1; index < arguments.length; index++) {
           var source = arguments[index];
           if (source !== undefined$1 && source !== null) {
               for (var nextKey in source) {
                   if (source.hasOwnProperty(nextKey)) {
                       output[nextKey] = source[nextKey];
                   }
               }
           }
       }
       return output;
   };
} else {
   assign = Object.assign;
}
24934
/**
* extend object.
* means that properties in dest will be overwritten by the ones in src.
* @param {Object} dest
* @param {Object} src
* @param {Boolean} [merge=false]
* @returns {Object} dest
*/
var extend = deprecate(function extend(dest, src, merge) {
   var keys = Object.keys(src);
   var i = 0;
   while (i < keys.length) {
       if (!merge || (merge && dest[keys[i]] === undefined$1)) {
           dest[keys[i]] = src[keys[i]];
       }
       i++;
   }
   return dest;
}, 'extend', 'Use `assign`.');
24954
/**
* merge the values from src in the dest.
* means that properties that exist in dest will not be overwritten by src
* @param {Object} dest
* @param {Object} src
* @returns {Object} dest
*/
var merge = deprecate(function merge(dest, src) {
   return extend(dest, src, true);
}, 'merge', 'Use `assign`.');
24965
/**
* simple class inheritance
* @param {Function} child
* @param {Function} base
* @param {Object} [properties]
*/
function inherit(child, base, properties) {
   var baseP = base.prototype,
       childP;
24975
   childP = child.prototype = Object.create(baseP);
   childP.constructor = child;
   childP._super = baseP;
24979
   if (properties) {
       assign(childP, properties);
   }
}
24984
/**
* simple function bind
* @param {Function} fn
* @param {Object} context
* @returns {Function}
*/
function bindFn(fn, context) {
   return function boundFn() {
       return fn.apply(context, arguments);
   };
}
24996
/**
* let a boolean value also be a function that must return a boolean
* this first item in args will be used as the context
* @param {Boolean|Function} val
* @param {Array} [args]
* @returns {Boolean}
*/
function boolOrFn(val, args) {
   if (typeof val == TYPE_FUNCTION) {
       return val.apply(args ? args[0] || undefined$1 : undefined$1, args);
   }
   return val;
}
25010
/**
* use the val2 when val1 is undefined
* @param {*} val1
* @param {*} val2
* @returns {*}
*/
function ifUndefined(val1, val2) {
   return (val1 === undefined$1) ? val2 : val1;
}
25020
/**
* addEventListener with multiple events at once
* @param {EventTarget} target
* @param {String} types
* @param {Function} handler
*/
function addEventListeners(target, types, handler) {
   each(splitStr(types), function(type) {
       target.addEventListener(type, handler, false);
   });
}
25032
/**
* removeEventListener with multiple events at once
* @param {EventTarget} target
* @param {String} types
* @param {Function} handler
*/
function removeEventListeners(target, types, handler) {
   each(splitStr(types), function(type) {
       target.removeEventListener(type, handler, false);
   });
}
25044
/**
* find if a node is in the given parent
* @method hasParent
* @param {HTMLElement} node
* @param {HTMLElement} parent
* @return {Boolean} found
*/
function hasParent(node, parent) {
   while (node) {
       if (node == parent) {
           return true;
       }
       node = node.parentNode;
   }
   return false;
}
25061
/**
* small indexOf wrapper
* @param {String} str
* @param {String} find
* @returns {Boolean} found
*/
function inStr(str, find) {
   return str.indexOf(find) > -1;
}
25071
/**
* split string on whitespace
* @param {String} str
* @returns {Array} words
*/
function splitStr(str) {
   return str.trim().split(/\s+/g);
}
25080
/**
* find if a array contains the object using indexOf or a simple polyFill
* @param {Array} src
* @param {String} find
* @param {String} [findByKey]
* @return {Boolean|Number} false when not found, or the index
*/
function inArray(src, find, findByKey) {
   if (src.indexOf && !findByKey) {
       return src.indexOf(find);
   } else {
       var i = 0;
       while (i < src.length) {
           if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
               return i;
           }
           i++;
       }
       return -1;
   }
}
25102
/**
* convert array-like objects to real arrays
* @param {Object} obj
* @returns {Array}
*/
function toArray(obj) {
   return Array.prototype.slice.call(obj, 0);
}
25111
/**
* unique array with objects based on a key (like 'id') or just by the array's value
* @param {Array} src [{id:1},{id:2},{id:1}]
* @param {String} [key]
* @param {Boolean} [sort=False]
* @returns {Array} [{id:1},{id:2}]
*/
function uniqueArray(src, key, sort) {
   var results = [];
   var values = [];
   var i = 0;
25123
   while (i < src.length) {
       var val = key ? src[i][key] : src[i];
       if (inArray(values, val) < 0) {
           results.push(src[i]);
       }
       values[i] = val;
       i++;
   }
25132
   if (sort) {
       if (!key) {
           results = results.sort();
       } else {
           results = results.sort(function sortUniqueArray(a, b) {
               return a[key] > b[key];
           });
       }
   }
25142
   return results;
}
25145
/**
* get the prefixed property
* @param {Object} obj
* @param {String} property
* @returns {String|Undefined} prefixed
*/
function prefixed(obj, property) {
   var prefix, prop;
   var camelProp = property[0].toUpperCase() + property.slice(1);
25155
   var i = 0;
   while (i < VENDOR_PREFIXES.length) {
       prefix = VENDOR_PREFIXES[i];
       prop = (prefix) ? prefix + camelProp : property;
25160
       if (prop in obj) {
           return prop;
       }
       i++;
   }
   return undefined$1;
}
25168
/**
* get a unique id
* @returns {number} uniqueId
*/
var _uniqueId = 1;
function uniqueId() {
   return _uniqueId++;
}
25177
/**
* get the window object of an element
* @param {HTMLElement} element
* @returns {DocumentView|Window}
*/
function getWindowForElement(element) {
   var doc = element.ownerDocument || element;
   return (doc.defaultView || doc.parentWindow || window);
}
25187
var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
25189
var SUPPORT_TOUCH = ('ontouchstart' in window);
var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined$1;
var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
25193
var INPUT_TYPE_TOUCH = 'touch';
var INPUT_TYPE_PEN = 'pen';
var INPUT_TYPE_MOUSE = 'mouse';
var INPUT_TYPE_KINECT = 'kinect';
25198
var COMPUTE_INTERVAL = 25;
25200
var INPUT_START = 1;
var INPUT_MOVE = 2;
var INPUT_END = 4;
var INPUT_CANCEL = 8;
25205
var DIRECTION_NONE = 1;
var DIRECTION_LEFT = 2;
var DIRECTION_RIGHT = 4;
var DIRECTION_UP = 8;
var DIRECTION_DOWN = 16;
25211
var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
25215
var PROPS_XY = ['x', 'y'];
var PROPS_CLIENT_XY = ['clientX', 'clientY'];
25218
/**
* create new input type manager
* @param {Manager} manager
* @param {Function} callback
* @returns {Input}
* @constructor
*/
function Input(manager, callback) {
   var self = this;
   this.manager = manager;
   this.callback = callback;
   this.element = manager.element;
   this.target = manager.options.inputTarget;
25232
   // smaller wrapper around the handler, for the scope and the enabled state of the manager,
   // so when disabled the input events are completely bypassed.
   this.domHandler = function(ev) {
       if (boolOrFn(manager.options.enable, [manager])) {
           self.handler(ev);
       }
   };
25240
   this.init();
25242
}
25244
Input.prototype = {
   /**
    * should handle the inputEvent data and trigger the callback
    * @virtual
    */
   handler: function() { },
25251
   /**
    * bind the events
    */
   init: function() {
       this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
       this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
       this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
   },
25260
   /**
    * unbind the events
    */
   destroy: function() {
       this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
       this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
       this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
   }
};
25270
/**
* create new input type manager
* called by the Manager constructor
* @param {Hammer} manager
* @returns {Input}
*/
function createInputInstance(manager) {
   var Type;
   var inputClass = manager.options.inputClass;
25280
   if (inputClass) {
       Type = inputClass;
   } else if (SUPPORT_POINTER_EVENTS) {
       Type = PointerEventInput;
   } else if (SUPPORT_ONLY_TOUCH) {
       Type = TouchInput;
   } else if (!SUPPORT_TOUCH) {
       Type = MouseInput;
   } else {
       Type = TouchMouseInput;
   }
   return new (Type)(manager, inputHandler);
}
25294
/**
* handle input events
* @param {Manager} manager
* @param {String} eventType
* @param {Object} input
*/
function inputHandler(manager, eventType, input) {
   var pointersLen = input.pointers.length;
   var changedPointersLen = input.changedPointers.length;
   var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
   var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
25306
   input.isFirst = !!isFirst;
   input.isFinal = !!isFinal;
25309
   if (isFirst) {
       manager.session = {};
   }
25313
   // source event is the normalized value of the domEvents
   // like 'touchstart, mouseup, pointerdown'
   input.eventType = eventType;
25317
   // compute scale, rotation etc
   computeInputData(manager, input);
25320
   // emit secret event
   manager.emit('hammer.input', input);
25323
   manager.recognize(input);
   manager.session.prevInput = input;
}
25327
/**
* extend the data with some usable properties like scale, rotate, velocity etc
* @param {Object} manager
* @param {Object} input
*/
function computeInputData(manager, input) {
   var session = manager.session;
   var pointers = input.pointers;
   var pointersLength = pointers.length;
25337
   // store the first input to calculate the distance and direction
   if (!session.firstInput) {
       session.firstInput = simpleCloneInputData(input);
   }
25342
   // to compute scale and rotation we need to store the multiple touches
   if (pointersLength > 1 && !session.firstMultiple) {
       session.firstMultiple = simpleCloneInputData(input);
   } else if (pointersLength === 1) {
       session.firstMultiple = false;
   }
25349
   var firstInput = session.firstInput;
   var firstMultiple = session.firstMultiple;
   var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
25353
   var center = input.center = getCenter(pointers);
   input.timeStamp = now();
   input.deltaTime = input.timeStamp - firstInput.timeStamp;
25357
   input.angle = getAngle(offsetCenter, center);
   input.distance = getDistance(offsetCenter, center);
25360
   computeDeltaXY(session, input);
   input.offsetDirection = getDirection(input.deltaX, input.deltaY);
25363
   var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
   input.overallVelocityX = overallVelocity.x;
   input.overallVelocityY = overallVelocity.y;
   input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;
25368
   input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
   input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
25371
   input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >
       session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);
25374
   computeIntervalInputData(session, input);
25376
   // find the correct target
   var target = manager.element;
   if (hasParent(input.srcEvent.target, target)) {
       target = input.srcEvent.target;
   }
   input.target = target;
}
25384
function computeDeltaXY(session, input) {
   var center = input.center;
   var offset = session.offsetDelta || {};
   var prevDelta = session.prevDelta || {};
   var prevInput = session.prevInput || {};
25390
   if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
       prevDelta = session.prevDelta = {
           x: prevInput.deltaX || 0,
           y: prevInput.deltaY || 0
       };
25396
       offset = session.offsetDelta = {
           x: center.x,
           y: center.y
       };
   }
25402
   input.deltaX = prevDelta.x + (center.x - offset.x);
   input.deltaY = prevDelta.y + (center.y - offset.y);
}
25406
/**
* velocity is calculated every x ms
* @param {Object} session
* @param {Object} input
*/
function computeIntervalInputData(session, input) {
   var last = session.lastInterval || input,
       deltaTime = input.timeStamp - last.timeStamp,
       velocity, velocityX, velocityY, direction;
25416
   if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined$1)) {
       var deltaX = input.deltaX - last.deltaX;
       var deltaY = input.deltaY - last.deltaY;
25420
       var v = getVelocity(deltaTime, deltaX, deltaY);
       velocityX = v.x;
       velocityY = v.y;
       velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
       direction = getDirection(deltaX, deltaY);
25426
       session.lastInterval = input;
   } else {
       // use latest velocity info if it doesn't overtake a minimum period
       velocity = last.velocity;
       velocityX = last.velocityX;
       velocityY = last.velocityY;
       direction = last.direction;
   }
25435
   input.velocity = velocity;
   input.velocityX = velocityX;
   input.velocityY = velocityY;
   input.direction = direction;
}
25441
/**
* create a simple clone from the input used for storage of firstInput and firstMultiple
* @param {Object} input
* @returns {Object} clonedInputData
*/
function simpleCloneInputData(input) {
   // make a simple copy of the pointers because we will get a reference if we don't
   // we only need clientXY for the calculations
   var pointers = [];
   var i = 0;
   while (i < input.pointers.length) {
       pointers[i] = {
           clientX: round(input.pointers[i].clientX),
           clientY: round(input.pointers[i].clientY)
       };
       i++;
   }
25459
   return {
       timeStamp: now(),
       pointers: pointers,
       center: getCenter(pointers),
       deltaX: input.deltaX,
       deltaY: input.deltaY
   };
}
25468
/**
* get the center of all the pointers
* @param {Array} pointers
* @return {Object} center contains `x` and `y` properties
*/
function getCenter(pointers) {
   var pointersLength = pointers.length;
25476
   // no need to loop when only one touch
   if (pointersLength === 1) {
       return {
           x: round(pointers[0].clientX),
           y: round(pointers[0].clientY)
       };
   }
25484
   var x = 0, y = 0, i = 0;
   while (i < pointersLength) {
       x += pointers[i].clientX;
       y += pointers[i].clientY;
       i++;
   }
25491
   return {
       x: round(x / pointersLength),
       y: round(y / pointersLength)
   };
}
25497
/**
* calculate the velocity between two points. unit is in px per ms.
* @param {Number} deltaTime
* @param {Number} x
* @param {Number} y
* @return {Object} velocity `x` and `y`
*/
function getVelocity(deltaTime, x, y) {
   return {
       x: x / deltaTime || 0,
       y: y / deltaTime || 0
   };
}
25511
/**
* get the direction between two points
* @param {Number} x
* @param {Number} y
* @return {Number} direction
*/
function getDirection(x, y) {
   if (x === y) {
       return DIRECTION_NONE;
   }
25522
   if (abs(x) >= abs(y)) {
       return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
   }
   return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
}
25528
/**
* calculate the absolute distance between two points
* @param {Object} p1 {x, y}
* @param {Object} p2 {x, y}
* @param {Array} [props] containing x and y keys
* @return {Number} distance
*/
function getDistance(p1, p2, props) {
   if (!props) {
       props = PROPS_XY;
   }
   var x = p2[props[0]] - p1[props[0]],
       y = p2[props[1]] - p1[props[1]];
25542
   return Math.sqrt((x * x) + (y * y));
}
25545
/**
* calculate the angle between two coordinates
* @param {Object} p1
* @param {Object} p2
* @param {Array} [props] containing x and y keys
* @return {Number} angle
*/
function getAngle(p1, p2, props) {
   if (!props) {
       props = PROPS_XY;
   }
   var x = p2[props[0]] - p1[props[0]],
       y = p2[props[1]] - p1[props[1]];
   return Math.atan2(y, x) * 180 / Math.PI;
}
25561
/**
* calculate the rotation degrees between two pointersets
* @param {Array} start array of pointers
* @param {Array} end array of pointers
* @return {Number} rotation
*/
function getRotation(start, end) {
   return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
}
25571
/**
* calculate the scale factor between two pointersets
* no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
* @param {Array} start array of pointers
* @param {Array} end array of pointers
* @return {Number} scale
*/
function getScale(start, end) {
   return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
}
25582
var MOUSE_INPUT_MAP = {
   mousedown: INPUT_START,
   mousemove: INPUT_MOVE,
   mouseup: INPUT_END
};
25588
var MOUSE_ELEMENT_EVENTS = 'mousedown';
var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
25591
/**
* Mouse events input
* @constructor
* @extends Input
*/
function MouseInput() {
   this.evEl = MOUSE_ELEMENT_EVENTS;
   this.evWin = MOUSE_WINDOW_EVENTS;
25600
   this.pressed = false; // mousedown state
25602
   Input.apply(this, arguments);
}
25605
inherit(MouseInput, Input, {
   /**
    * handle mouse events
    * @param {Object} ev
    */
   handler: function MEhandler(ev) {
       var eventType = MOUSE_INPUT_MAP[ev.type];
25613
       // on start we want to have the left mouse button down
       if (eventType & INPUT_START && ev.button === 0) {
           this.pressed = true;
       }
25618
       if (eventType & INPUT_MOVE && ev.which !== 1) {
           eventType = INPUT_END;
       }
25622
       // mouse must be down
       if (!this.pressed) {
           return;
       }
25627
       if (eventType & INPUT_END) {
           this.pressed = false;
       }
25631
       this.callback(this.manager, eventType, {
           pointers: [ev],
           changedPointers: [ev],
           pointerType: INPUT_TYPE_MOUSE,
           srcEvent: ev
       });
   }
});
25640
var POINTER_INPUT_MAP = {
   pointerdown: INPUT_START,
   pointermove: INPUT_MOVE,
   pointerup: INPUT_END,
   pointercancel: INPUT_CANCEL,
   pointerout: INPUT_CANCEL
};
25648
// in IE10 the pointer types is defined as an enum
var IE10_POINTER_TYPE_ENUM = {
   2: INPUT_TYPE_TOUCH,
   3: INPUT_TYPE_PEN,
   4: INPUT_TYPE_MOUSE,
   5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
};
25656
var POINTER_ELEMENT_EVENTS = 'pointerdown';
var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
25659
// IE10 has prefixed support, and case-sensitive
if (window.MSPointerEvent && !window.PointerEvent) {
   POINTER_ELEMENT_EVENTS = 'MSPointerDown';
   POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
}
25665
/**
* Pointer events input
* @constructor
* @extends Input
*/
function PointerEventInput() {
   this.evEl = POINTER_ELEMENT_EVENTS;
   this.evWin = POINTER_WINDOW_EVENTS;
25674
   Input.apply(this, arguments);
25676
   this.store = (this.manager.session.pointerEvents = []);
}
25679
inherit(PointerEventInput, Input, {
   /**
    * handle mouse events
    * @param {Object} ev
    */
   handler: function PEhandler(ev) {
       var store = this.store;
       var removePointer = false;
25688
       var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
       var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
       var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
25692
       var isTouch = (pointerType == INPUT_TYPE_TOUCH);
25694
       // get index of the event in the store
       var storeIndex = inArray(store, ev.pointerId, 'pointerId');
25697
       // start and mouse must be down
       if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
           if (storeIndex < 0) {
               store.push(ev);
               storeIndex = store.length - 1;
           }
       } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
           removePointer = true;
       }
25707
       // it not found, so the pointer hasn't been down (so it's probably a hover)
       if (storeIndex < 0) {
           return;
       }
25712
       // update the event in the store
       store[storeIndex] = ev;
25715
       this.callback(this.manager, eventType, {
           pointers: store,
           changedPointers: [ev],
           pointerType: pointerType,
           srcEvent: ev
       });
25722
       if (removePointer) {
           // remove from the store
           store.splice(storeIndex, 1);
       }
   }
});
25729
var SINGLE_TOUCH_INPUT_MAP = {
   touchstart: INPUT_START,
   touchmove: INPUT_MOVE,
   touchend: INPUT_END,
   touchcancel: INPUT_CANCEL
};
25736
var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
25739
/**
* Touch events input
* @constructor
* @extends Input
*/
function SingleTouchInput() {
   this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
   this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
   this.started = false;
25749
   Input.apply(this, arguments);
}
25752
inherit(SingleTouchInput, Input, {
   handler: function TEhandler(ev) {
       var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
25756
       // should we handle the touch events?
       if (type === INPUT_START) {
           this.started = true;
       }
25761
       if (!this.started) {
           return;
       }
25765
       var touches = normalizeSingleTouches.call(this, ev, type);
25767
       // when done, reset the started state
       if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
           this.started = false;
       }
25772
       this.callback(this.manager, type, {
           pointers: touches[0],
           changedPointers: touches[1],
           pointerType: INPUT_TYPE_TOUCH,
           srcEvent: ev
       });
   }
});
25781
/**
* @this {TouchInput}
* @param {Object} ev
* @param {Number} type flag
* @returns {undefined|Array} [all, changed]
*/
function normalizeSingleTouches(ev, type) {
   var all = toArray(ev.touches);
   var changed = toArray(ev.changedTouches);
25791
   if (type & (INPUT_END | INPUT_CANCEL)) {
       all = uniqueArray(all.concat(changed), 'identifier', true);
   }
25795
   return [all, changed];
}
25798
var TOUCH_INPUT_MAP = {
   touchstart: INPUT_START,
   touchmove: INPUT_MOVE,
   touchend: INPUT_END,
   touchcancel: INPUT_CANCEL
};
25805
var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
25807
/**
* Multi-user touch events input
* @constructor
* @extends Input
*/
function TouchInput() {
   this.evTarget = TOUCH_TARGET_EVENTS;
   this.targetIds = {};
25816
   Input.apply(this, arguments);
}
25819
inherit(TouchInput, Input, {
   handler: function MTEhandler(ev) {
       var type = TOUCH_INPUT_MAP[ev.type];
       var touches = getTouches.call(this, ev, type);
       if (!touches) {
           return;
       }
25827
       this.callback(this.manager, type, {
           pointers: touches[0],
           changedPointers: touches[1],
           pointerType: INPUT_TYPE_TOUCH,
           srcEvent: ev
       });
   }
});
25836
/**
* @this {TouchInput}
* @param {Object} ev
* @param {Number} type flag
* @returns {undefined|Array} [all, changed]
*/
function getTouches(ev, type) {
   var allTouches = toArray(ev.touches);
   var targetIds = this.targetIds;
25846
   // when there is only one touch, the process can be simplified
   if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
       targetIds[allTouches[0].identifier] = true;
       return [allTouches, allTouches];
   }
25852
   var i,
       targetTouches,
       changedTouches = toArray(ev.changedTouches),
       changedTargetTouches = [],
       target = this.target;
25858
   // get target touches from touches
   targetTouches = allTouches.filter(function(touch) {
       return hasParent(touch.target, target);
   });
25863
   // collect touches
   if (type === INPUT_START) {
       i = 0;
       while (i < targetTouches.length) {
           targetIds[targetTouches[i].identifier] = true;
           i++;
       }
   }
25872
   // filter changed touches to only contain touches that exist in the collected target ids
   i = 0;
   while (i < changedTouches.length) {
       if (targetIds[changedTouches[i].identifier]) {
           changedTargetTouches.push(changedTouches[i]);
       }
25879
       // cleanup removed touches
       if (type & (INPUT_END | INPUT_CANCEL)) {
           delete targetIds[changedTouches[i].identifier];
       }
       i++;
   }
25886
   if (!changedTargetTouches.length) {
       return;
   }
25890
   return [
       // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
       uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
       changedTargetTouches
   ];
}
25897
/**
* Combined touch and mouse input
*
* Touch has a higher priority then mouse, and while touching no mouse events are allowed.
* This because touch devices also emit mouse events while doing a touch.
*
* @constructor
* @extends Input
*/
25907
var DEDUP_TIMEOUT = 2500;
var DEDUP_DISTANCE = 25;
25910
function TouchMouseInput() {
   Input.apply(this, arguments);
25913
   var handler = bindFn(this.handler, this);
   this.touch = new TouchInput(this.manager, handler);
   this.mouse = new MouseInput(this.manager, handler);
25917
   this.primaryTouch = null;
   this.lastTouches = [];
}
25921
inherit(TouchMouseInput, Input, {
   /**
    * handle mouse and touch events
    * @param {Hammer} manager
    * @param {String} inputEvent
    * @param {Object} inputData
    */
   handler: function TMEhandler(manager, inputEvent, inputData) {
       var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),
           isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
25932
       if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
           return;
       }
25936
       // when we're in a touch event, record touches to  de-dupe synthetic mouse event
       if (isTouch) {
           recordTouches.call(this, inputEvent, inputData);
       } else if (isMouse && isSyntheticEvent.call(this, inputData)) {
           return;
       }
25943
       this.callback(manager, inputEvent, inputData);
   },
25946
   /**
    * remove the event listeners
    */
   destroy: function destroy() {
       this.touch.destroy();
       this.mouse.destroy();
   }
});
25955
function recordTouches(eventType, eventData) {
   if (eventType & INPUT_START) {
       this.primaryTouch = eventData.changedPointers[0].identifier;
       setLastTouch.call(this, eventData);
   } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
       setLastTouch.call(this, eventData);
   }
}
25964
function setLastTouch(eventData) {
   var touch = eventData.changedPointers[0];
25967
   if (touch.identifier === this.primaryTouch) {
       var lastTouch = {x: touch.clientX, y: touch.clientY};
       this.lastTouches.push(lastTouch);
       var lts = this.lastTouches;
       var removeLastTouch = function() {
           var i = lts.indexOf(lastTouch);
           if (i > -1) {
               lts.splice(i, 1);
           }
       };
       setTimeout(removeLastTouch, DEDUP_TIMEOUT);
   }
}
25981
function isSyntheticEvent(eventData) {
   var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;
   for (var i = 0; i < this.lastTouches.length; i++) {
       var t = this.lastTouches[i];
       var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
       if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
           return true;
       }
   }
   return false;
}
25993
var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined$1;
25996
// magical touchAction value
var TOUCH_ACTION_COMPUTE = 'compute';
var TOUCH_ACTION_AUTO = 'auto';
var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
var TOUCH_ACTION_NONE = 'none';
var TOUCH_ACTION_PAN_X = 'pan-x';
var TOUCH_ACTION_PAN_Y = 'pan-y';
var TOUCH_ACTION_MAP = getTouchActionProps();
26005
/**
* Touch Action
* sets the touchAction property or uses the js alternative
* @param {Manager} manager
* @param {String} value
* @constructor
*/
function TouchAction(manager, value) {
   this.manager = manager;
   this.set(value);
}
26017
TouchAction.prototype = {
   /**
    * set the touchAction value on the element or enable the polyfill
    * @param {String} value
    */
   set: function(value) {
       // find out the touch-action by the event handlers
       if (value == TOUCH_ACTION_COMPUTE) {
           value = this.compute();
       }
26028
       if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
           this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
       }
       this.actions = value.toLowerCase().trim();
   },
26034
   /**
    * just re-set the touchAction value
    */
   update: function() {
       this.set(this.manager.options.touchAction);
   },
26041
   /**
    * compute the value for the touchAction property based on the recognizer's settings
    * @returns {String} value
    */
   compute: function() {
       var actions = [];
       each(this.manager.recognizers, function(recognizer) {
           if (boolOrFn(recognizer.options.enable, [recognizer])) {
               actions = actions.concat(recognizer.getTouchAction());
           }
       });
       return cleanTouchActions(actions.join(' '));
   },
26055
   /**
    * this method is called on each input cycle and provides the preventing of the browser behavior
    * @param {Object} input
    */
   preventDefaults: function(input) {
       var srcEvent = input.srcEvent;
       var direction = input.offsetDirection;
26063
       // if the touch action did prevented once this session
       if (this.manager.session.prevented) {
           srcEvent.preventDefault();
           return;
       }
26069
       var actions = this.actions;
       var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
       var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
       var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
26074
       if (hasNone) {
           //do not prevent defaults if this is a tap gesture
26077
           var isTapPointer = input.pointers.length === 1;
           var isTapMovement = input.distance < 2;
           var isTapTouchTime = input.deltaTime < 250;
26081
           if (isTapPointer && isTapMovement && isTapTouchTime) {
               return;
           }
       }
26086
       if (hasPanX && hasPanY) {
           // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
           return;
       }
26091
       if (hasNone ||
           (hasPanY && direction & DIRECTION_HORIZONTAL) ||
           (hasPanX && direction & DIRECTION_VERTICAL)) {
           return this.preventSrc(srcEvent);
       }
   },
26098
   /**
    * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
    * @param {Object} srcEvent
    */
   preventSrc: function(srcEvent) {
       this.manager.session.prevented = true;
       srcEvent.preventDefault();
   }
};
26108
/**
* when the touchActions are collected they are not a valid value, so we need to clean things up. *
* @param {String} actions
* @returns {*}
*/
function cleanTouchActions(actions) {
   // none
   if (inStr(actions, TOUCH_ACTION_NONE)) {
       return TOUCH_ACTION_NONE;
   }
26119
   var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
   var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
26122
   // if both pan-x and pan-y are set (different recognizers
   // for different directions, e.g. horizontal pan but vertical swipe?)
   // we need none (as otherwise with pan-x pan-y combined none of these
   // recognizers will work, since the browser would handle all panning
   if (hasPanX && hasPanY) {
       return TOUCH_ACTION_NONE;
   }
26130
   // pan-x OR pan-y
   if (hasPanX || hasPanY) {
       return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
   }
26135
   // manipulation
   if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
       return TOUCH_ACTION_MANIPULATION;
   }
26140
   return TOUCH_ACTION_AUTO;
}
26143
function getTouchActionProps() {
   if (!NATIVE_TOUCH_ACTION) {
       return false;
   }
   var touchMap = {};
   var cssSupports = window.CSS && window.CSS.supports;
   ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {
26151
       // If css.supports is not supported but there is native touch-action assume it supports
       // all values. This is the case for IE 10 and 11.
       touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;
   });
   return touchMap;
}
26158
/**
* Recognizer flow explained; *
* All recognizers have the initial state of POSSIBLE when a input session starts.
* The definition of a input session is from the first input until the last input, with all it's movement in it. *
* Example session for mouse-input: mousedown -> mousemove -> mouseup
*
* On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
* which determines with state it should be.
*
* If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
* POSSIBLE to give it another change on the next cycle.
*
*               Possible
*                  |
*            +-----+---------------+
*            |                     |
*      +-----+-----+               |
*      |           |               |
*   Failed      Cancelled          |
*                          +-------+------+
*                          |              |
*                      Recognized       Began
*                                         |
*                                      Changed
*                                         |
*                                  Ended/Recognized
*/
var STATE_POSSIBLE = 1;
var STATE_BEGAN = 2;
var STATE_CHANGED = 4;
var STATE_ENDED = 8;
var STATE_RECOGNIZED = STATE_ENDED;
var STATE_CANCELLED = 16;
var STATE_FAILED = 32;
26193
/**
* Recognizer
* Every recognizer needs to extend from this class.
* @constructor
* @param {Object} options
*/
function Recognizer(options) {
   this.options = assign({}, this.defaults, options || {});
26202
   this.id = uniqueId();
26204
   this.manager = null;
26206
   // default is enable true
   this.options.enable = ifUndefined(this.options.enable, true);
26209
   this.state = STATE_POSSIBLE;
26211
   this.simultaneous = {};
   this.requireFail = [];
}
26215
Recognizer.prototype = {
   /**
    * @virtual
    * @type {Object}
    */
   defaults: {},
26222
   /**
    * set options
    * @param {Object} options
    * @return {Recognizer}
    */
   set: function(options) {
       assign(this.options, options);
26230
       // also update the touchAction, in case something changed about the directions/enabled state
       this.manager && this.manager.touchAction.update();
       return this;
   },
26235
   /**
    * recognize simultaneous with an other recognizer.
    * @param {Recognizer} otherRecognizer
    * @returns {Recognizer} this
    */
   recognizeWith: function(otherRecognizer) {
       if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
           return this;
       }
26245
       var simultaneous = this.simultaneous;
       otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
       if (!simultaneous[otherRecognizer.id]) {
           simultaneous[otherRecognizer.id] = otherRecognizer;
           otherRecognizer.recognizeWith(this);
       }
       return this;
   },
26254
   /**
    * drop the simultaneous link. it doesnt remove the link on the other recognizer.
    * @param {Recognizer} otherRecognizer
    * @returns {Recognizer} this
    */
   dropRecognizeWith: function(otherRecognizer) {
       if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
           return this;
       }
26264
       otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
       delete this.simultaneous[otherRecognizer.id];
       return this;
   },
26269
   /**
    * recognizer can only run when an other is failing
    * @param {Recognizer} otherRecognizer
    * @returns {Recognizer} this
    */
   requireFailure: function(otherRecognizer) {
       if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
           return this;
       }
26279
       var requireFail = this.requireFail;
       otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
       if (inArray(requireFail, otherRecognizer) === -1) {
           requireFail.push(otherRecognizer);
           otherRecognizer.requireFailure(this);
       }
       return this;
   },
26288
   /**
    * drop the requireFailure link. it does not remove the link on the other recognizer.
    * @param {Recognizer} otherRecognizer
    * @returns {Recognizer} this
    */
   dropRequireFailure: function(otherRecognizer) {
       if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
           return this;
       }
26298
       otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
       var index = inArray(this.requireFail, otherRecognizer);
       if (index > -1) {
           this.requireFail.splice(index, 1);
       }
       return this;
   },
26306
   /**
    * has require failures boolean
    * @returns {boolean}
    */
   hasRequireFailures: function() {
       return this.requireFail.length > 0;
   },
26314
   /**
    * if the recognizer can recognize simultaneous with an other recognizer
    * @param {Recognizer} otherRecognizer
    * @returns {Boolean}
    */
   canRecognizeWith: function(otherRecognizer) {
       return !!this.simultaneous[otherRecognizer.id];
   },
26323
   /**
    * You should use `tryEmit` instead of `emit` directly to check
    * that all the needed recognizers has failed before emitting.
    * @param {Object} input
    */
   emit: function(input) {
       var self = this;
       var state = this.state;
26332
       function emit(event) {
           self.manager.emit(event, input);
       }
26336
       // 'panstart' and 'panmove'
       if (state < STATE_ENDED) {
           emit(self.options.event + stateStr(state));
       }
26341
       emit(self.options.event); // simple 'eventName' events
26343
       if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)
           emit(input.additionalEvent);
       }
26347
       // panend and pancancel
       if (state >= STATE_ENDED) {
           emit(self.options.event + stateStr(state));
       }
   },
26353
   /**
    * Check that all the require failure recognizers has failed,
    * if true, it emits a gesture event,
    * otherwise, setup the state to FAILED.
    * @param {Object} input
    */
   tryEmit: function(input) {
       if (this.canEmit()) {
           return this.emit(input);
       }
       // it's failing anyway
       this.state = STATE_FAILED;
   },
26367
   /**
    * can we emit?
    * @returns {boolean}
    */
   canEmit: function() {
       var i = 0;
       while (i < this.requireFail.length) {
           if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
               return false;
           }
           i++;
       }
       return true;
   },
26382
   /**
    * update the recognizer
    * @param {Object} inputData
    */
   recognize: function(inputData) {
       // make a new copy of the inputData
       // so we can change the inputData without messing up the other recognizers
       var inputDataClone = assign({}, inputData);
26391
       // is is enabled and allow recognizing?
       if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
           this.reset();
           this.state = STATE_FAILED;
           return;
       }
26398
       // reset when we've reached the end
       if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
           this.state = STATE_POSSIBLE;
       }
26403
       this.state = this.process(inputDataClone);
26405
       // the recognizer has recognized a gesture
       // so trigger an event
       if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
           this.tryEmit(inputDataClone);
       }
   },
26412
   /**
    * return the state of the recognizer
    * the actual recognizing happens in this method
    * @virtual
    * @param {Object} inputData
    * @returns {Const} STATE
    */
   process: function(inputData) { }, // jshint ignore:line
26421
   /**
    * return the preferred touch-action
    * @virtual
    * @returns {Array}
    */
   getTouchAction: function() { },
26428
   /**
    * called when the gesture isn't allowed to recognize
    * like when another is being recognized or it is disabled
    * @virtual
    */
   reset: function() { }
};
26436
/**
* get a usable string, used as event postfix
* @param {Const} state
* @returns {String} state
*/
function stateStr(state) {
   if (state & STATE_CANCELLED) {
       return 'cancel';
   } else if (state & STATE_ENDED) {
       return 'end';
   } else if (state & STATE_CHANGED) {
       return 'move';
   } else if (state & STATE_BEGAN) {
       return 'start';
   }
   return '';
}
26454
/**
* direction cons to string
* @param {Const} direction
* @returns {String}
*/
function directionStr(direction) {
   if (direction == DIRECTION_DOWN) {
       return 'down';
   } else if (direction == DIRECTION_UP) {
       return 'up';
   } else if (direction == DIRECTION_LEFT) {
       return 'left';
   } else if (direction == DIRECTION_RIGHT) {
       return 'right';
   }
   return '';
}
26472
/**
* get a recognizer by name if it is bound to a manager
* @param {Recognizer|String} otherRecognizer
* @param {Recognizer} recognizer
* @returns {Recognizer}
*/
function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
   var manager = recognizer.manager;
   if (manager) {
       return manager.get(otherRecognizer);
   }
   return otherRecognizer;
}
26486
/**
* This recognizer is just used as a base for the simple attribute recognizers.
* @constructor
* @extends Recognizer
*/
function AttrRecognizer() {
   Recognizer.apply(this, arguments);
}
26495
inherit(AttrRecognizer, Recognizer, {
   /**
    * @namespace
    * @memberof AttrRecognizer
    */
   defaults: {
       /**
        * @type {Number}
        * @default 1
        */
       pointers: 1
   },
26508
   /**
    * Used to check if it the recognizer receives valid input, like input.distance > 10.
    * @memberof AttrRecognizer
    * @param {Object} input
    * @returns {Boolean} recognized
    */
   attrTest: function(input) {
       var optionPointers = this.options.pointers;
       return optionPointers === 0 || input.pointers.length === optionPointers;
   },
26519
   /**
    * Process the input and return the state for the recognizer
    * @memberof AttrRecognizer
    * @param {Object} input
    * @returns {*} State
    */
   process: function(input) {
       var state = this.state;
       var eventType = input.eventType;
26529
       var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
       var isValid = this.attrTest(input);
26532
       // on cancel input and we've recognized before, return STATE_CANCELLED
       if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
           return state | STATE_CANCELLED;
       } else if (isRecognized || isValid) {
           if (eventType & INPUT_END) {
               return state | STATE_ENDED;
           } else if (!(state & STATE_BEGAN)) {
               return STATE_BEGAN;
           }
           return state | STATE_CHANGED;
       }
       return STATE_FAILED;
   }
});
26547
/**
* Pan
* Recognized when the pointer is down and moved in the allowed direction.
* @constructor
* @extends AttrRecognizer
*/
function PanRecognizer() {
   AttrRecognizer.apply(this, arguments);
26556
   this.pX = null;
   this.pY = null;
}
26560
inherit(PanRecognizer, AttrRecognizer, {
   /**
    * @namespace
    * @memberof PanRecognizer
    */
   defaults: {
       event: 'pan',
       threshold: 10,
       pointers: 1,
       direction: DIRECTION_ALL
   },
26572
   getTouchAction: function() {
       var direction = this.options.direction;
       var actions = [];
       if (direction & DIRECTION_HORIZONTAL) {
           actions.push(TOUCH_ACTION_PAN_Y);
       }
       if (direction & DIRECTION_VERTICAL) {
           actions.push(TOUCH_ACTION_PAN_X);
       }
       return actions;
   },
26584
   directionTest: function(input) {
       var options = this.options;
       var hasMoved = true;
       var distance = input.distance;
       var direction = input.direction;
       var x = input.deltaX;
       var y = input.deltaY;
26592
       // lock to axis?
       if (!(direction & options.direction)) {
           if (options.direction & DIRECTION_HORIZONTAL) {
               direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
               hasMoved = x != this.pX;
               distance = Math.abs(input.deltaX);
           } else {
               direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;
               hasMoved = y != this.pY;
               distance = Math.abs(input.deltaY);
           }
       }
       input.direction = direction;
       return hasMoved && distance > options.threshold && direction & options.direction;
   },
26608
   attrTest: function(input) {
       return AttrRecognizer.prototype.attrTest.call(this, input) &&
           (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
   },
26613
   emit: function(input) {
26615
       this.pX = input.deltaX;
       this.pY = input.deltaY;
26618
       var direction = directionStr(input.direction);
26620
       if (direction) {
           input.additionalEvent = this.options.event + direction;
       }
       this._super.emit.call(this, input);
   }
});
26627
/**
* Pinch
* Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
* @constructor
* @extends AttrRecognizer
*/
function PinchRecognizer() {
   AttrRecognizer.apply(this, arguments);
}
26637
inherit(PinchRecognizer, AttrRecognizer, {
   /**
    * @namespace
    * @memberof PinchRecognizer
    */
   defaults: {
       event: 'pinch',
       threshold: 0,
       pointers: 2
   },
26648
   getTouchAction: function() {
       return [TOUCH_ACTION_NONE];
   },
26652
   attrTest: function(input) {
       return this._super.attrTest.call(this, input) &&
           (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
   },
26657
   emit: function(input) {
       if (input.scale !== 1) {
           var inOut = input.scale < 1 ? 'in' : 'out';
           input.additionalEvent = this.options.event + inOut;
       }
       this._super.emit.call(this, input);
   }
});
26666
/**
* Press
* Recognized when the pointer is down for x ms without any movement.
* @constructor
* @extends Recognizer
*/
function PressRecognizer() {
   Recognizer.apply(this, arguments);
26675
   this._timer = null;
   this._input = null;
}
26679
inherit(PressRecognizer, Recognizer, {
   /**
    * @namespace
    * @memberof PressRecognizer
    */
   defaults: {
       event: 'press',
       pointers: 1,
       time: 251, // minimal time of the pointer to be pressed
       threshold: 9 // a minimal movement is ok, but keep it low
   },
26691
   getTouchAction: function() {
       return [TOUCH_ACTION_AUTO];
   },
26695
   process: function(input) {
       var options = this.options;
       var validPointers = input.pointers.length === options.pointers;
       var validMovement = input.distance < options.threshold;
       var validTime = input.deltaTime > options.time;
26701
       this._input = input;
26703
       // we only allow little movement
       // and we've reached an end event, so a tap is possible
       if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {
           this.reset();
       } else if (input.eventType & INPUT_START) {
           this.reset();
           this._timer = setTimeoutContext(function() {
               this.state = STATE_RECOGNIZED;
               this.tryEmit();
           }, options.time, this);
       } else if (input.eventType & INPUT_END) {
           return STATE_RECOGNIZED;
       }
       return STATE_FAILED;
   },
26719
   reset: function() {
       clearTimeout(this._timer);
   },
26723
   emit: function(input) {
       if (this.state !== STATE_RECOGNIZED) {
           return;
       }
26728
       if (input && (input.eventType & INPUT_END)) {
           this.manager.emit(this.options.event + 'up', input);
       } else {
           this._input.timeStamp = now();
           this.manager.emit(this.options.event, this._input);
       }
   }
});
26737
/**
* Rotate
* Recognized when two or more pointer are moving in a circular motion.
* @constructor
* @extends AttrRecognizer
*/
function RotateRecognizer() {
   AttrRecognizer.apply(this, arguments);
}
26747
inherit(RotateRecognizer, AttrRecognizer, {
   /**
    * @namespace
    * @memberof RotateRecognizer
    */
   defaults: {
       event: 'rotate',
       threshold: 0,
       pointers: 2
   },
26758
   getTouchAction: function() {
       return [TOUCH_ACTION_NONE];
   },
26762
   attrTest: function(input) {
       return this._super.attrTest.call(this, input) &&
           (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
   }
});
26768
/**
* Swipe
* Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
* @constructor
* @extends AttrRecognizer
*/
function SwipeRecognizer() {
   AttrRecognizer.apply(this, arguments);
}
26778
inherit(SwipeRecognizer, AttrRecognizer, {
   /**
    * @namespace
    * @memberof SwipeRecognizer
    */
   defaults: {
       event: 'swipe',
       threshold: 10,
       velocity: 0.3,
       direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
       pointers: 1
   },
26791
   getTouchAction: function() {
       return PanRecognizer.prototype.getTouchAction.call(this);
   },
26795
   attrTest: function(input) {
       var direction = this.options.direction;
       var velocity;
26799
       if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
           velocity = input.overallVelocity;
       } else if (direction & DIRECTION_HORIZONTAL) {
           velocity = input.overallVelocityX;
       } else if (direction & DIRECTION_VERTICAL) {
           velocity = input.overallVelocityY;
       }
26807
       return this._super.attrTest.call(this, input) &&
           direction & input.offsetDirection &&
           input.distance > this.options.threshold &&
           input.maxPointers == this.options.pointers &&
           abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
   },
26814
   emit: function(input) {
       var direction = directionStr(input.offsetDirection);
       if (direction) {
           this.manager.emit(this.options.event + direction, input);
       }
26820
       this.manager.emit(this.options.event, input);
   }
});
26824
/**
* A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
* between the given interval and position. The delay option can be used to recognize multi-taps without firing
* a single tap.
*
* The eventData from the emitted event contains the property `tapCount`, which contains the amount of
* multi-taps being recognized.
* @constructor
* @extends Recognizer
*/
function TapRecognizer() {
   Recognizer.apply(this, arguments);
26837
   // previous time and center,
   // used for tap counting
   this.pTime = false;
   this.pCenter = false;
26842
   this._timer = null;
   this._input = null;
   this.count = 0;
}
26847
inherit(TapRecognizer, Recognizer, {
   /**
    * @namespace
    * @memberof PinchRecognizer
    */
   defaults: {
       event: 'tap',
       pointers: 1,
       taps: 1,
       interval: 300, // max time between the multi-tap taps
       time: 250, // max time of the pointer to be down (like finger on the screen)
       threshold: 9, // a minimal movement is ok, but keep it low
       posThreshold: 10 // a multi-tap can be a bit off the initial position
   },
26862
   getTouchAction: function() {
       return [TOUCH_ACTION_MANIPULATION];
   },
26866
   process: function(input) {
       var options = this.options;
26869
       var validPointers = input.pointers.length === options.pointers;
       var validMovement = input.distance < options.threshold;
       var validTouchTime = input.deltaTime < options.time;
26873
       this.reset();
26875
       if ((input.eventType & INPUT_START) && (this.count === 0)) {
           return this.failTimeout();
       }
26879
       // we only allow little movement
       // and we've reached an end event, so a tap is possible
       if (validMovement && validTouchTime && validPointers) {
           if (input.eventType != INPUT_END) {
               return this.failTimeout();
           }
26886
           var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
           var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
26889
           this.pTime = input.timeStamp;
           this.pCenter = input.center;
26892
           if (!validMultiTap || !validInterval) {
               this.count = 1;
           } else {
               this.count += 1;
           }
26898
           this._input = input;
26900
           // if tap count matches we have recognized it,
           // else it has began recognizing...
           var tapCount = this.count % options.taps;
           if (tapCount === 0) {
               // no failing requirements, immediately trigger the tap event
               // or wait as long as the multitap interval to trigger
               if (!this.hasRequireFailures()) {
                   return STATE_RECOGNIZED;
               } else {
                   this._timer = setTimeoutContext(function() {
                       this.state = STATE_RECOGNIZED;
                       this.tryEmit();
                   }, options.interval, this);
                   return STATE_BEGAN;
               }
           }
       }
       return STATE_FAILED;
   },
26920
   failTimeout: function() {
       this._timer = setTimeoutContext(function() {
           this.state = STATE_FAILED;
       }, this.options.interval, this);
       return STATE_FAILED;
   },
26927
   reset: function() {
       clearTimeout(this._timer);
   },
26931
   emit: function() {
       if (this.state == STATE_RECOGNIZED) {
           this._input.tapCount = this.count;
           this.manager.emit(this.options.event, this._input);
       }
   }
});
26939
/**
* Simple way to create a manager with a default set of recognizers.
* @param {HTMLElement} element
* @param {Object} [options]
* @constructor
*/
function Hammer(element, options) {
   options = options || {};
   options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
   return new Manager(element, options);
}
26951
/**
* @const {string}
*/
Hammer.VERSION = '2.0.7';
26956
/**
* default settings
* @namespace
*/
Hammer.defaults = {
   /**
    * set if DOM events are being triggered.
    * But this is slower and unused by simple implementations, so disabled by default.
    * @type {Boolean}
    * @default false
    */
   domEvents: false,
26969
   /**
    * The value for the touchAction property/fallback.
    * When set to `compute` it will magically set the correct value based on the added recognizers.
    * @type {String}
    * @default compute
    */
   touchAction: TOUCH_ACTION_COMPUTE,
26977
   /**
    * @type {Boolean}
    * @default true
    */
   enable: true,
26983
   /**
    * EXPERIMENTAL FEATURE -- can be removed/changed
    * Change the parent input target element.
    * If Null, then it is being set the to main element.
    * @type {Null|EventTarget}
    * @default null
    */
   inputTarget: null,
26992
   /**
    * force an input class
    * @type {Null|Function}
    * @default null
    */
   inputClass: null,
26999
   /**
    * Default recognizer setup when calling `Hammer()`
    * When creating a new Manager these will be skipped.
    * @type {Array}
    */
   preset: [
       // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
       [RotateRecognizer, {enable: false}],
       [PinchRecognizer, {enable: false}, ['rotate']],
       [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],
       [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],
       [TapRecognizer],
       [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],
       [PressRecognizer]
   ],
27015
   /**
    * Some CSS properties can be used to improve the working of Hammer.
    * Add them to this method and they will be set when creating a new Manager.
    * @namespace
    */
   cssProps: {
       /**
        * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
        * @type {String}
        * @default 'none'
        */
       userSelect: 'none',
27028
       /**
        * Disable the Windows Phone grippers when pressing an element.
        * @type {String}
        * @default 'none'
        */
       touchSelect: 'none',
27035
       /**
        * Disables the default callout shown when you touch and hold a touch target.
        * On iOS, when you touch and hold a touch target such as a link, Safari displays
        * a callout containing information about the link. This property allows you to disable that callout.
        * @type {String}
        * @default 'none'
        */
       touchCallout: 'none',
27044
       /**
        * Specifies whether zooming is enabled. Used by IE10>
        * @type {String}
        * @default 'none'
        */
       contentZooming: 'none',
27051
       /**
        * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
        * @type {String}
        * @default 'none'
        */
       userDrag: 'none',
27058
       /**
        * Overrides the highlight color shown when the user taps a link or a JavaScript
        * clickable element in iOS. This property obeys the alpha value, if specified.
        * @type {String}
        * @default 'rgba(0,0,0,0)'
        */
       tapHighlightColor: 'rgba(0,0,0,0)'
   }
};
27068
var STOP = 1;
var FORCED_STOP = 2;
27071
/**
* Manager
* @param {HTMLElement} element
* @param {Object} [options]
* @constructor
*/
function Manager(element, options) {
   this.options = assign({}, Hammer.defaults, options || {});
27080
   this.options.inputTarget = this.options.inputTarget || element;
27082
   this.handlers = {};
   this.session = {};
   this.recognizers = [];
   this.oldCssProps = {};
27087
   this.element = element;
   this.input = createInputInstance(this);
   this.touchAction = new TouchAction(this, this.options.touchAction);
27091
   toggleCssProps(this, true);
27093
   each(this.options.recognizers, function(item) {
       var recognizer = this.add(new (item[0])(item[1]));
       item[2] && recognizer.recognizeWith(item[2]);
       item[3] && recognizer.requireFailure(item[3]);
   }, this);
}
27100
Manager.prototype = {
   /**
    * set options
    * @param {Object} options
    * @returns {Manager}
    */
   set: function(options) {
       assign(this.options, options);
27109
       // Options that need a little more setup
       if (options.touchAction) {
           this.touchAction.update();
       }
       if (options.inputTarget) {
           // Clean up existing event listeners and reinitialize
           this.input.destroy();
           this.input.target = options.inputTarget;
           this.input.init();
       }
       return this;
   },
27122
   /**
    * stop recognizing for this session.
    * This session will be discarded, when a new [input]start event is fired.
    * When forced, the recognizer cycle is stopped immediately.
    * @param {Boolean} [force]
    */
   stop: function(force) {
       this.session.stopped = force ? FORCED_STOP : STOP;
   },
27132
   /**
    * run the recognizers!
    * called by the inputHandler function on every movement of the pointers (touches)
    * it walks through all the recognizers and tries to detect the gesture that is being made
    * @param {Object} inputData
    */
   recognize: function(inputData) {
       var session = this.session;
       if (session.stopped) {
           return;
       }
27144
       // run the touch-action polyfill
       this.touchAction.preventDefaults(inputData);
27147
       var recognizer;
       var recognizers = this.recognizers;
27150
       // this holds the recognizer that is being recognized.
       // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
       // if no recognizer is detecting a thing, it is set to `null`
       var curRecognizer = session.curRecognizer;
27155
       // reset when the last recognizer is recognized
       // or when we're in a new session
       if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
           curRecognizer = session.curRecognizer = null;
       }
27161
       var i = 0;
       while (i < recognizers.length) {
           recognizer = recognizers[i];
27165
           // find out if we are allowed try to recognize the input for this one.
           // 1.   allow if the session is NOT forced stopped (see the .stop() method)
           // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
           //      that is being recognized.
           // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
           //      this can be setup with the `recognizeWith()` method on the recognizer.
           if (session.stopped !== FORCED_STOP && ( // 1
                   !curRecognizer || recognizer == curRecognizer || // 2
                   recognizer.canRecognizeWith(curRecognizer))) { // 3
               recognizer.recognize(inputData);
           } else {
               recognizer.reset();
           }
27179
           // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
           // current active recognizer. but only if we don't already have an active recognizer
           if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
               curRecognizer = session.curRecognizer = recognizer;
           }
           i++;
       }
   },
27188
   /**
    * get a recognizer by its event name.
    * @param {Recognizer|String} recognizer
    * @returns {Recognizer|Null}
    */
   get: function(recognizer) {
       if (recognizer instanceof Recognizer) {
           return recognizer;
       }
27198
       var recognizers = this.recognizers;
       for (var i = 0; i < recognizers.length; i++) {
           if (recognizers[i].options.event == recognizer) {
               return recognizers[i];
           }
       }
       return null;
   },
27207
   /**
    * add a recognizer to the manager
    * existing recognizers with the same event name will be removed
    * @param {Recognizer} recognizer
    * @returns {Recognizer|Manager}
    */
   add: function(recognizer) {
       if (invokeArrayArg(recognizer, 'add', this)) {
           return this;
       }
27218
       // remove existing
       var existing = this.get(recognizer.options.event);
       if (existing) {
           this.remove(existing);
       }
27224
       this.recognizers.push(recognizer);
       recognizer.manager = this;
27227
       this.touchAction.update();
       return recognizer;
   },
27231
   /**
    * remove a recognizer by name or instance
    * @param {Recognizer|String} recognizer
    * @returns {Manager}
    */
   remove: function(recognizer) {
       if (invokeArrayArg(recognizer, 'remove', this)) {
           return this;
       }
27241
       recognizer = this.get(recognizer);
27243
       // let's make sure this recognizer exists
       if (recognizer) {
           var recognizers = this.recognizers;
           var index = inArray(recognizers, recognizer);
27248
           if (index !== -1) {
               recognizers.splice(index, 1);
               this.touchAction.update();
           }
       }
27254
       return this;
   },
27257
   /**
    * bind event
    * @param {String} events
    * @param {Function} handler
    * @returns {EventEmitter} this
    */
   on: function(events, handler) {
       if (events === undefined$1) {
           return;
       }
       if (handler === undefined$1) {
           return;
       }
27271
       var handlers = this.handlers;
       each(splitStr(events), function(event) {
           handlers[event] = handlers[event] || [];
           handlers[event].push(handler);
       });
       return this;
   },
27279
   /**
    * unbind event, leave emit blank to remove all handlers
    * @param {String} events
    * @param {Function} [handler]
    * @returns {EventEmitter} this
    */
   off: function(events, handler) {
       if (events === undefined$1) {
           return;
       }
27290
       var handlers = this.handlers;
       each(splitStr(events), function(event) {
           if (!handler) {
               delete handlers[event];
           } else {
               handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
           }
       });
       return this;
   },
27301
   /**
    * emit event to the listeners
    * @param {String} event
    * @param {Object} data
    */
   emit: function(event, data) {
       // we also want to trigger dom events
       if (this.options.domEvents) {
           triggerDomEvent(event, data);
       }
27312
       // no handlers, so skip it all
       var handlers = this.handlers[event] && this.handlers[event].slice();
       if (!handlers || !handlers.length) {
           return;
       }
27318
       data.type = event;
       data.preventDefault = function() {
           data.srcEvent.preventDefault();
       };
27323
       var i = 0;
       while (i < handlers.length) {
           handlers[i](data);
           i++;
       }
   },
27330
   /**
    * destroy the manager and unbinds all events
    * it doesn't unbind dom events, that is the user own responsibility
    */
   destroy: function() {
       this.element && toggleCssProps(this, false);
27337
       this.handlers = {};
       this.session = {};
       this.input.destroy();
       this.element = null;
   }
};
27344
/**
* add/remove the css properties as defined in manager.options.cssProps
* @param {Manager} manager
* @param {Boolean} add
*/
function toggleCssProps(manager, add) {
   var element = manager.element;
   if (!element.style) {
       return;
   }
   var prop;
   each(manager.options.cssProps, function(value, name) {
       prop = prefixed(element.style, name);
       if (add) {
           manager.oldCssProps[prop] = element.style[prop];
           element.style[prop] = value;
       } else {
           element.style[prop] = manager.oldCssProps[prop] || '';
       }
   });
   if (!add) {
       manager.oldCssProps = {};
   }
}
27369
/**
* trigger dom event
* @param {String} event
* @param {Object} data
*/
function triggerDomEvent(event, data) {
   var gestureEvent = document.createEvent('Event');
   gestureEvent.initEvent(event, true, true);
   gestureEvent.gesture = data;
   data.target.dispatchEvent(gestureEvent);
}
27381
assign(Hammer, {
   INPUT_START: INPUT_START,
   INPUT_MOVE: INPUT_MOVE,
   INPUT_END: INPUT_END,
   INPUT_CANCEL: INPUT_CANCEL,
27387
   STATE_POSSIBLE: STATE_POSSIBLE,
   STATE_BEGAN: STATE_BEGAN,
   STATE_CHANGED: STATE_CHANGED,
   STATE_ENDED: STATE_ENDED,
   STATE_RECOGNIZED: STATE_RECOGNIZED,
   STATE_CANCELLED: STATE_CANCELLED,
   STATE_FAILED: STATE_FAILED,
27395
   DIRECTION_NONE: DIRECTION_NONE,
   DIRECTION_LEFT: DIRECTION_LEFT,
   DIRECTION_RIGHT: DIRECTION_RIGHT,
   DIRECTION_UP: DIRECTION_UP,
   DIRECTION_DOWN: DIRECTION_DOWN,
   DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
   DIRECTION_VERTICAL: DIRECTION_VERTICAL,
   DIRECTION_ALL: DIRECTION_ALL,
27404
   Manager: Manager,
   Input: Input,
   TouchAction: TouchAction,
27408
   TouchInput: TouchInput,
   MouseInput: MouseInput,
   PointerEventInput: PointerEventInput,
   TouchMouseInput: TouchMouseInput,
   SingleTouchInput: SingleTouchInput,
27414
   Recognizer: Recognizer,
   AttrRecognizer: AttrRecognizer,
   Tap: TapRecognizer,
   Pan: PanRecognizer,
   Swipe: SwipeRecognizer,
   Pinch: PinchRecognizer,
   Rotate: RotateRecognizer,
   Press: PressRecognizer,
27423
   on: addEventListeners,
   off: removeEventListeners,
   each: each,
   merge: merge,
   extend: extend,
   assign: assign,
   inherit: inherit,
   bindFn: bindFn,
   prefixed: prefixed
});
27434
// this prevents errors when Hammer is loaded in the presence of an AMD
//  style loader but by script tag, not by the loader.
var freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line
freeGlobal.Hammer = Hammer;
27439
if (typeof undefined$1 === 'function' && undefined$1.amd) {
   undefined$1(function() {
       return Hammer;
   });
} else if (module.exports) {
   module.exports = Hammer;
} else {
   window[exportName] = Hammer;
}
27449
})(window, document, 'Hammer');
}(hammer));
27452
var Hammer = hammer.exports;
27454
var MIN_ZOOM = 0.2,
   MAX_ZOOM = 4;
27457
var mouseEvents = [
 'mousedown',
 'mouseup',
 'mouseover',
 'mouseout',
 'click',
 'dblclick'
];
27466
function get(service, injector) {
 return injector.get(service, false);
}
27470
function stopEvent(event) {
27472
 event.preventDefault();
27474
 if (typeof event.stopPropagation === 'function') {
   event.stopPropagation();
 } else if (event.srcEvent && typeof event.srcEvent.stopPropagation === 'function') {
27478
   // iPhone & iPad
   event.srcEvent.stopPropagation();
 }
27482
 if (typeof event.stopImmediatePropagation === 'function') {
   event.stopImmediatePropagation();
 }
}
27487
27488
function createTouchRecognizer(node) {
27490
 function stopMouse(event) {
27492
   forEach$2(mouseEvents, function(e) {
     componentEvent.bind(node, e, stopEvent, true);
   });
 }
27497
 function allowMouse(event) {
   setTimeout(function() {
     forEach$2(mouseEvents, function(e) {
       componentEvent.unbind(node, e, stopEvent, true);
     });
   }, 500);
 }
27505
 componentEvent.bind(node, 'touchstart', stopMouse, true);
 componentEvent.bind(node, 'touchend', allowMouse, true);
 componentEvent.bind(node, 'touchcancel', allowMouse, true);
27509
 // A touch event recognizer that handles
 // touch events only (we know, we can already handle
 // mouse events out of the box)
27513
 var recognizer = new Hammer.Manager(node, {
   inputClass: Hammer.TouchInput,
   recognizers: [],
   domEvents: true
 });
27519
27520
 var tap = new Hammer.Tap();
 var pan = new Hammer.Pan({ threshold: 10 });
 var press = new Hammer.Press();
 var pinch = new Hammer.Pinch();
27525
 var doubleTap = new Hammer.Tap({ event: 'doubletap', taps: 2 });
27527
 pinch.requireFailure(pan);
 pinch.requireFailure(press);
27530
 recognizer.add([ pan, press, pinch, doubleTap, tap ]);
27532
 recognizer.reset = function(force) {
   var recognizers = this.recognizers,
       session = this.session;
27536
   if (session.stopped) {
     return;
   }
27540
   recognizer.stop(force);
27542
   setTimeout(function() {
     var i, r;
     for (i = 0; (r = recognizers[i]); i++) {
       r.reset();
       r.state = 8; // FAILED STATE
     }
27549
     session.curRecognizer = null;
   }, 0);
 };
27553
 recognizer.on('hammer.input', function(event) {
   if (event.srcEvent.defaultPrevented) {
     recognizer.reset(true);
   }
 });
27559
 return recognizer;
}
27562
/**
* A plugin that provides touch events for elements.
*
* @param {EventBus} eventBus
* @param {InteractionEvents} interactionEvents
*/
function TouchInteractionEvents(
   injector, canvas, eventBus,
   elementRegistry, interactionEvents) {
27572
 // optional integrations
 var dragging = get('dragging', injector),
     move = get('move', injector),
     contextPad = get('contextPad', injector),
     palette = get('palette', injector);
27578
 // the touch recognizer
 var recognizer;
27581
 function handler(type, buttonType) {
27583
   return function(event) {
27585
     var gfx = getGfx(event.target),
         element = gfx && elementRegistry.get(gfx);
27588
     // translate into an actual mouse click event
     if (buttonType) {
       event.srcEvent.button = buttonType;
     }
27593
     return interactionEvents.fire(type, event, element);
   };
 }
27597
27598
 function getGfx(target) {
   var node = closest(target, 'svg, .djs-element', true);
   return node;
 }
27603
 function initEvents(svg) {
27605
   // touch recognizer
   recognizer = createTouchRecognizer(svg);
27608
   function startGrabCanvas(event) {
27610
     var lx = 0, ly = 0;
27612
     function update(e) {
27614
       var dx = e.deltaX - lx,
           dy = e.deltaY - ly;
27617
       canvas.scroll({ dx: dx, dy: dy });
27619
       lx = e.deltaX;
       ly = e.deltaY;
     }
27623
     function end(e) {
       recognizer.off('panmove', update);
       recognizer.off('panend', end);
       recognizer.off('pancancel', end);
     }
27629
     recognizer.on('panmove', update);
     recognizer.on('panend', end);
     recognizer.on('pancancel', end);
   }
27634
   function startGrab(event) {
27636
     var gfx = getGfx(event.target),
         element = gfx && elementRegistry.get(gfx);
27639
     // recognizer
     if (move && canvas.getRootElement() !== element) {
       return move.start(event, element, true);
     } else {
       startGrabCanvas();
     }
   }
27647
   function startZoom(e) {
27649
     var zoom = canvas.zoom(),
         mid = e.center;
27652
     function update(e) {
27654
       var ratio = 1 - (1 - e.scale) / 1.50,
           newZoom = Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, ratio * zoom));
27657
       canvas.zoom(newZoom, mid);
27659
       stopEvent(e);
     }
27662
     function end(e) {
       recognizer.off('pinchmove', update);
       recognizer.off('pinchend', end);
       recognizer.off('pinchcancel', end);
27667
       recognizer.reset(true);
     }
27670
     recognizer.on('pinchmove', update);
     recognizer.on('pinchend', end);
     recognizer.on('pinchcancel', end);
   }
27675
   recognizer.on('tap', handler('element.click'));
   recognizer.on('doubletap', handler('element.dblclick', 1));
27678
   recognizer.on('panstart', startGrab);
   recognizer.on('press', startGrab);
27681
   recognizer.on('pinchstart', startZoom);
 }
27684
 if (dragging) {
27686
   // simulate hover during dragging
   eventBus.on('drag.move', function(event) {
27689
     var originalEvent = event.originalEvent;
27691
     if (!originalEvent || originalEvent instanceof MouseEvent) {
       return;
     }
27695
     var position = toPoint(originalEvent);
27697
     // this gets really expensive ...
     var node = document.elementFromPoint(position.x, position.y),
         gfx = getGfx(node),
         element = gfx && elementRegistry.get(gfx);
27702
     if (element !== event.hover) {
       if (event.hover) {
         dragging.out(event);
       }
27707
       if (element) {
         dragging.hover({ element: element, gfx: gfx });
27710
         event.hover = element;
         event.hoverGfx = gfx;
       }
     }
   });
 }
27717
 if (contextPad) {
27719
   eventBus.on('contextPad.create', function(event) {
     var node = event.pad.html;
27722
     // touch recognizer
     var padRecognizer = createTouchRecognizer(node);
27725
     padRecognizer.on('panstart', function(event) {
       contextPad.trigger('dragstart', event, true);
     });
27729
     padRecognizer.on('press', function(event) {
       contextPad.trigger('dragstart', event, true);
     });
27733
     padRecognizer.on('tap', function(event) {
       contextPad.trigger('click', event);
     });
   });
 }
27739
 if (palette) {
   eventBus.on('palette.create', function(event) {
     var node = event.container;
27743
     // touch recognizer
     var padRecognizer = createTouchRecognizer(node);
27746
     padRecognizer.on('panstart', function(event) {
       palette.trigger('dragstart', event, true);
     });
27750
     padRecognizer.on('press', function(event) {
       palette.trigger('dragstart', event, true);
     });
27754
     padRecognizer.on('tap', function(event) {
       palette.trigger('click', event);
     });
   });
 }
27760
 eventBus.on('canvas.init', function(event) {
   initEvents(event.svg);
 });
}
27765
27766
TouchInteractionEvents.$inject = [
 'injector',
 'canvas',
 'eventBus',
 'elementRegistry',
 'interactionEvents',
 'touchFix'
];
27775
function TouchFix(canvas, eventBus) {
27777
 var self = this;
27779
 eventBus.on('canvas.init', function(e) {
   self.addBBoxMarker(e.svg);
 });
}
27784
TouchFix.$inject = [ 'canvas', 'eventBus' ];
27786
27787
/**
* Safari mobile (iOS 7) does not fire touchstart event in <SVG> element
* if there is no shape between 0,0 and viewport elements origin.
*
* So touchstart event is only fired when the <g class="viewport"> element was hit.
* Putting an element over and below the 'viewport' fixes that behavior.
*/
TouchFix.prototype.addBBoxMarker = function(svg) {
27796
 var markerStyle = {
   fill: 'none',
   class: 'outer-bound-marker'
 };
27801
 var rect1 = create$1('rect');
 attr$1(rect1, {
   x: -10000,
   y: 10000,
   width: 10,
   height: 10
 });
 attr$1(rect1, markerStyle);
27810
 append(svg, rect1);
27812
 var rect2 = create$1('rect');
 attr$1(rect2, {
   x: 10000,
   y: 10000,
   width: 10,
   height: 10
 });
 attr$1(rect2, markerStyle);
27821
 append(svg, rect2);
};
27824
var TouchModule$1 = {
 __depends__: [ InteractionEventsModule$1 ],
 __init__: [ 'touchInteractionEvents' ],
 touchInteractionEvents: [ 'type', TouchInteractionEvents ],
 touchFix: [ 'type', TouchFix ]
};
27831
var TouchModule = {
 __depends__: [
   TouchModule$1
 ]
};
27837
function last(arr) {
 return arr && arr[arr.length - 1];
}
27841
function sortTopOrMiddle(element) {
 return element.y;
}
27845
function sortLeftOrCenter(element) {
 return element.x;
}
27849
/**
* Sorting functions for different types of alignment
*
* @type {Object}
*
* @return {Function}
*/
var ALIGNMENT_SORTING = {
 left: sortLeftOrCenter,
 center: sortLeftOrCenter,
 right: function(element) {
   return element.x + element.width;
 },
 top: sortTopOrMiddle,
 middle: sortTopOrMiddle,
 bottom: function(element) {
   return element.y + element.height;
 }
};
27869
27870
function AlignElements$1(modeling) {
 this._modeling = modeling;
}
27874
AlignElements$1.$inject = [ 'modeling' ];
27876
27877
/**
* Get the relevant "axis" and "dimension" related to the current type of alignment
*
* @param  {string} type left|right|center|top|bottom|middle
*
* @return {Object} { axis, dimension }
*/
AlignElements$1.prototype._getOrientationDetails = function(type) {
 var vertical = [ 'top', 'bottom', 'middle' ],
     axis = 'x',
     dimension = 'width';
27889
 if (vertical.indexOf(type) !== -1) {
   axis = 'y';
   dimension = 'height';
 }
27894
 return {
   axis: axis,
   dimension: dimension
 };
};
27900
AlignElements$1.prototype._isType = function(type, types) {
 return types.indexOf(type) !== -1;
};
27904
/**
* Get a point on the relevant axis where elements should align to
*
* @param  {string} type left|right|center|top|bottom|middle
* @param  {Array} sortedElements
*
* @return {Object}
*/
AlignElements$1.prototype._alignmentPosition = function(type, sortedElements) {
 var orientation = this._getOrientationDetails(type),
     axis = orientation.axis,
     dimension = orientation.dimension,
     alignment = {},
     centers = {},
     hasSharedCenters = false,
     centeredElements,
     firstElement,
     lastElement;
27923
 function getMiddleOrTop(first, last) {
   return Math.round((first[axis] + last[axis] + last[dimension]) / 2);
 }
27927
 if (this._isType(type, [ 'left', 'top' ])) {
   alignment[type] = sortedElements[0][axis];
27930
 } else if (this._isType(type, [ 'right', 'bottom' ])) {
   lastElement = last(sortedElements);
27933
   alignment[type] = lastElement[axis] + lastElement[dimension];
27935
 } else if (this._isType(type, [ 'center', 'middle' ])) {
27937
   // check if there is a center shared by more than one shape
   // if not, just take the middle of the range
   forEach$2(sortedElements, function(element) {
     var center = element[axis] + Math.round(element[dimension] / 2);
27942
     if (centers[center]) {
       centers[center].elements.push(element);
     } else {
       centers[center] = {
         elements: [ element ],
         center: center
       };
     }
   });
27952
   centeredElements = sortBy(centers, function(center) {
     if (center.elements.length > 1) {
       hasSharedCenters = true;
     }
27957
     return center.elements.length;
   });
27960
   if (hasSharedCenters) {
     alignment[type] = last(centeredElements).center;
27963
     return alignment;
   }
27966
   firstElement = sortedElements[0];
27968
   sortedElements = sortBy(sortedElements, function(element) {
     return element[axis] + element[dimension];
   });
27972
   lastElement = last(sortedElements);
27974
   alignment[type] = getMiddleOrTop(firstElement, lastElement);
 }
27977
 return alignment;
};
27980
/**
* Executes the alignment of a selection of elements
*
* @param  {Array} elements
* @param  {string} type left|right|center|top|bottom|middle
*/
AlignElements$1.prototype.trigger = function(elements, type) {
 var modeling = this._modeling;
27989
 var filteredElements = filter(elements, function(element) {
   return !(element.waypoints || element.host || element.labelTarget);
 });
27993
 if (filteredElements.length < 2) {
   return;
 }
27997
 var sortFn = ALIGNMENT_SORTING[type];
27999
 var sortedElements = sortBy(filteredElements, sortFn);
28001
 var alignment = this._alignmentPosition(type, sortedElements);
28003
 modeling.alignElements(sortedElements, alignment);
};
28006
var AlignElementsModule = {
 __init__: [ 'alignElements' ],
 alignElements: [ 'type', AlignElements$1 ]
};
28011
// padding to detect element placement
var PLACEMENT_DETECTION_PAD = 10;
28014
var DEFAULT_DISTANCE = 50;
28016
var DEFAULT_MAX_DISTANCE = 250;
28018
28019
/**
* Get free position starting from given position.
*
* @param {djs.model.Shape} source
* @param {djs.model.Shape} element
* @param {Point} position
* @param {Function} getNextPosition
*
* @return {Point}
*/
function findFreePosition(source, element, position, getNextPosition) {
 var connectedAtPosition;
28032
 while ((connectedAtPosition = getConnectedAtPosition(source, position, element))) {
   position = getNextPosition(element, position, connectedAtPosition);
 }
28036
 return position;
}
28039
/**
* Returns function that returns next position.
*
* @param {Object} nextPositionDirection
* @param {Object} [nextPositionDirection.x]
* @param {Object} [nextPositionDirection.y]
*
* @returns {Function}
*/
function generateGetNextPosition(nextPositionDirection) {
 return function(element, previousPosition, connectedAtPosition) {
   var nextPosition = {
     x: previousPosition.x,
     y: previousPosition.y
   };
28055
   [ 'x', 'y' ].forEach(function(axis) {
28057
     var nextPositionDirectionForAxis = nextPositionDirection[ axis ];
28059
     if (!nextPositionDirectionForAxis) {
       return;
     }
28063
     var dimension = axis === 'x' ? 'width' : 'height';
28065
     var margin = nextPositionDirectionForAxis.margin,
         minDistance = nextPositionDirectionForAxis.minDistance;
28068
     if (margin < 0) {
       nextPosition[ axis ] = Math.min(
         connectedAtPosition[ axis ] + margin - element[ dimension ] / 2,
         previousPosition[ axis ] - minDistance + margin
       );
     } else {
       nextPosition[ axis ] = Math.max(
         connectedAtPosition[ axis ] + connectedAtPosition[ dimension ] + margin + element[ dimension ] / 2,
         previousPosition[ axis ] + minDistance + margin
       );
     }
   });
28081
   return nextPosition;
 };
}
28085
/**
* Return target at given position, if defined.
*
* This takes connected elements from host and attachers
* into account, too.
*/
function getConnectedAtPosition(source, position, element) {
28093
 var bounds = {
   x: position.x - (element.width / 2),
   y: position.y - (element.height / 2),
   width: element.width,
   height: element.height
 };
28100
 var closure = getAutoPlaceClosure(source);
28102
 return find(closure, function(target) {
28104
   if (target === element) {
     return false;
   }
28108
   var orientation = getOrientation(target, bounds, PLACEMENT_DETECTION_PAD);
28110
   return orientation === 'intersect';
 });
}
28114
/**
* Compute optimal distance between source and target based on existing connections to and from source.
* Assumes left-to-right and top-to-down modeling.
*
* @param {djs.model.Shape} source
* @param {Object} [hints]
* @param {number} [hints.defaultDistance]
* @param {string} [hints.direction]
* @param {Function} [hints.filter]
* @param {Function} [hints.getWeight]
* @param {number} [hints.maxDistance]
* @param {string} [hints.reference]
*
* @return {number}
*/
function getConnectedDistance(source, hints) {
 if (!hints) {
   hints = {};
 }
28134
 // targets > sources by default
 function getDefaultWeight(connection) {
   return connection.source === source ? 1 : -1;
 }
28139
 var defaultDistance = hints.defaultDistance || DEFAULT_DISTANCE,
     direction = hints.direction || 'e',
     filter = hints.filter,
     getWeight = hints.getWeight || getDefaultWeight,
     maxDistance = hints.maxDistance || DEFAULT_MAX_DISTANCE,
     reference = hints.reference || 'start';
28146
 if (!filter) {
   filter = noneFilter;
 }
28150
 function getDistance(a, b) {
   if (direction === 'n') {
     if (reference === 'start') {
       return asTRBL(a).top - asTRBL(b).bottom;
     } else if (reference === 'center') {
       return asTRBL(a).top - getMid(b).y;
     } else {
       return asTRBL(a).top - asTRBL(b).top;
     }
   } else if (direction === 'w') {
     if (reference === 'start') {
       return asTRBL(a).left - asTRBL(b).right;
     } else if (reference === 'center') {
       return asTRBL(a).left - getMid(b).x;
     } else {
       return asTRBL(a).left - asTRBL(b).left;
     }
   } else if (direction === 's') {
     if (reference === 'start') {
       return asTRBL(b).top - asTRBL(a).bottom;
     } else if (reference === 'center') {
       return getMid(b).y - asTRBL(a).bottom;
     } else {
       return asTRBL(b).bottom - asTRBL(a).bottom;
     }
   } else {
     if (reference === 'start') {
       return asTRBL(b).left - asTRBL(a).right;
     } else if (reference === 'center') {
       return getMid(b).x - asTRBL(a).right;
     } else {
       return asTRBL(b).right - asTRBL(a).right;
     }
   }
 }
28186
 var sourcesDistances = source.incoming
   .filter(filter)
   .map(function(connection) {
     var weight = getWeight(connection);
28191
     var distance = weight < 0
       ? getDistance(connection.source, source)
       : getDistance(source, connection.source);
28195
     return {
       id: connection.source.id,
       distance: distance,
       weight: weight
     };
   });
28202
 var targetsDistances = source.outgoing
   .filter(filter)
   .map(function(connection) {
     var weight = getWeight(connection);
28207
     var distance = weight > 0
       ? getDistance(source, connection.target)
       : getDistance(connection.target, source);
28211
     return {
       id: connection.target.id,
       distance: distance,
       weight: weight
     };
   });
28218
 var distances = sourcesDistances.concat(targetsDistances).reduce(function(accumulator, currentValue) {
   accumulator[ currentValue.id + '__weight_' + currentValue.weight ] = currentValue;
28221
   return accumulator;
 }, {});
28224
 var distancesGrouped = reduce(distances, function(accumulator, currentValue) {
   var distance = currentValue.distance,
       weight = currentValue.weight;
28228
   if (distance < 0 || distance > maxDistance) {
     return accumulator;
   }
28232
   if (!accumulator[ String(distance) ]) {
     accumulator[ String(distance) ] = 0;
   }
28236
   accumulator[ String(distance) ] += 1 * weight;
28238
   if (!accumulator.distance || accumulator[ accumulator.distance ] < accumulator[ String(distance) ]) {
     accumulator.distance = distance;
   }
28242
   return accumulator;
 }, {});
28245
 return distancesGrouped.distance || defaultDistance;
}
28248
/**
* Returns all connected elements around the given source.
*
* This includes:
*
*   - connected elements
*   - host connected elements
*   - attachers connected elements
*
* @param  {djs.model.Shape} source
*
* @return {Array<djs.model.Shape>}
*/
function getAutoPlaceClosure(source) {
28263
 var allConnected = getConnected(source);
28265
 if (source.host) {
   allConnected = allConnected.concat(getConnected(source.host));
 }
28269
 if (source.attachers) {
   allConnected = allConnected.concat(source.attachers.reduce(function(shapes, attacher) {
     return shapes.concat(getConnected(attacher));
   }, []));
 }
28275
 return allConnected;
}
28278
function getConnected(element) {
 return getTargets(element).concat(getSources(element));
}
28282
function getSources(shape) {
 return shape.incoming.map(function(connection) {
   return connection.source;
 });
}
28288
function getTargets(shape) {
 return shape.outgoing.map(function(connection) {
   return connection.target;
 });
}
28294
function noneFilter() {
 return true;
}
28298
var LOW_PRIORITY$j = 100;
28300
28301
/**
* A service that places elements connected to existing ones
* to an appropriate position in an _automated_ fashion.
*
* @param {EventBus} eventBus
* @param {Modeling} modeling
*/
function AutoPlace$1(eventBus, modeling, canvas) {
28310
 eventBus.on('autoPlace', LOW_PRIORITY$j, function(context) {
   var shape = context.shape,
       source = context.source;
28314
   return getNewShapePosition$1(source, shape);
 });
28317
 eventBus.on('autoPlace.end', function(event) {
   canvas.scrollToElement(event.shape);
 });
28321
 /**
  * Append shape to source at appropriate position.
  *
  * @param {djs.model.Shape} source
  * @param {djs.model.Shape} shape
  *
  * @return {djs.model.Shape} appended shape
  */
 this.append = function(source, shape, hints) {
28331
   eventBus.fire('autoPlace.start', {
     source: source,
     shape: shape
   });
28336
   // allow others to provide the position
   var position = eventBus.fire('autoPlace', {
     source: source,
     shape: shape
   });
28342
   var newShape = modeling.appendShape(source, shape, position, source.parent, hints);
28344
   eventBus.fire('autoPlace.end', {
     source: source,
     shape: newShape
   });
28349
   return newShape;
 };
28352
}
28354
AutoPlace$1.$inject = [
 'eventBus',
 'modeling',
 'canvas'
];
28360
// helpers //////////
28362
/**
* Find the new position for the target element to
* connect to source.
*
* @param  {djs.model.Shape} source
* @param  {djs.model.Shape} element
* @param  {Object} [hints]
* @param  {Object} [hints.defaultDistance]
*
* @returns {Point}
*/
function getNewShapePosition$1(source, element, hints) {
 if (!hints) {
   hints = {};
 }
28378
 var distance = hints.defaultDistance || DEFAULT_DISTANCE;
28380
 var sourceMid = getMid(source),
     sourceTrbl = asTRBL(source);
28383
 // simply put element right next to source
 return {
   x: sourceTrbl.right + distance + element.width / 2,
   y: sourceMid.y
 };
}
28390
/**
* Select element after auto placement.
*
* @param {EventBus} eventBus
* @param {Selection} selection
*/
function AutoPlaceSelectionBehavior(eventBus, selection) {
28398
 eventBus.on('autoPlace.end', 500, function(e) {
   selection.select(e.shape);
 });
28402
}
28404
AutoPlaceSelectionBehavior.$inject = [
 'eventBus',
 'selection'
];
28409
var AutoPlaceModule$1 = {
 __init__: [ 'autoPlaceSelectionBehavior' ],
 autoPlace: [ 'type', AutoPlace$1 ],
 autoPlaceSelectionBehavior: [ 'type', AutoPlaceSelectionBehavior ]
};
28415
/**
* Return the parent of the element with any of the given types.
*
* @param {djs.model.Base} element
* @param {string|Array<string>} anyType
*
* @return {djs.model.Base}
*/
function getParent(element, anyType) {
28425
 if (typeof anyType === 'string') {
   anyType = [ anyType ];
 }
28429
 while ((element = element.parent)) {
   if (isAny(element, anyType)) {
     return element;
   }
 }
28435
 return null;
}
28438
/**
* Find the new position for the target element to
* connect to source.
*
* @param  {djs.model.Shape} source
* @param  {djs.model.Shape} element
*
* @return {Point}
*/
function getNewShapePosition(source, element) {
28449
 if (is$1(element, 'bpmn:TextAnnotation')) {
   return getTextAnnotationPosition(source, element);
 }
28453
 if (isAny(element, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ])) {
   return getDataElementPosition(source, element);
 }
28457
 if (is$1(element, 'bpmn:FlowNode')) {
   return getFlowNodePosition(source, element);
 }
}
28462
/**
* Always try to place element right of source;
* compute actual distance from previous nodes in flow.
*/
function getFlowNodePosition(source, element) {
28468
 var sourceTrbl = asTRBL(source);
 var sourceMid = getMid(source);
28471
 var horizontalDistance = getConnectedDistance(source, {
   filter: function(connection) {
     return is$1(connection, 'bpmn:SequenceFlow');
   }
 });
28477
 var margin = 30,
     minDistance = 80,
     orientation = 'left';
28481
 if (is$1(source, 'bpmn:BoundaryEvent')) {
   orientation = getOrientation(source, source.host, -25);
28484
   if (orientation.indexOf('top') !== -1) {
     margin *= -1;
   }
 }
28489
 var position = {
   x: sourceTrbl.right + horizontalDistance + element.width / 2,
   y: sourceMid.y + getVerticalDistance(orientation, minDistance)
 };
28494
 var nextPositionDirection = {
   y: {
     margin: margin,
     minDistance: minDistance
   }
 };
28501
 return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
}
28504
28505
function getVerticalDistance(orientation, minDistance) {
 if (orientation.indexOf('top') != -1) {
   return -1 * minDistance;
 } else if (orientation.indexOf('bottom') != -1) {
   return minDistance;
 } else {
   return 0;
 }
}
28515
28516
/**
* Always try to place text annotations top right of source.
*/
function getTextAnnotationPosition(source, element) {
28521
 var sourceTrbl = asTRBL(source);
28523
 var position = {
   x: sourceTrbl.right + element.width / 2,
   y: sourceTrbl.top - 50 - element.height / 2
 };
28528
 var nextPositionDirection = {
   y: {
     margin: -30,
     minDistance: 20
   }
 };
28535
 return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
}
28538
28539
/**
* Always put element bottom right of source.
*/
function getDataElementPosition(source, element) {
28544
 var sourceTrbl = asTRBL(source);
28546
 var position = {
   x: sourceTrbl.right - 10 + element.width / 2,
   y: sourceTrbl.bottom + 40 + element.width / 2
 };
28551
 var nextPositionDirection = {
   x: {
     margin: 30,
     minDistance: 30
   }
 };
28558
 return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
}
28561
/**
* BPMN auto-place behavior.
*
* @param {EventBus} eventBus
*/
function AutoPlace(eventBus) {
 eventBus.on('autoPlace', function(context) {
   var shape = context.shape,
       source = context.source;
28571
   return getNewShapePosition(source, shape);
 });
}
28575
AutoPlace.$inject = [ 'eventBus' ];
28577
var AutoPlaceModule = {
 __depends__: [ AutoPlaceModule$1 ],
 __init__: [ 'bpmnAutoPlace' ],
 bpmnAutoPlace: [ 'type', AutoPlace ]
};
28583
/**
* An auto resize component that takes care of expanding a parent element
* if child elements are created or moved close the parents edge.
*
* @param {EventBus} eventBus
* @param {ElementRegistry} elementRegistry
* @param {Modeling} modeling
* @param {Rules} rules
*/
function AutoResize(eventBus, elementRegistry, modeling, rules) {
28594
 CommandInterceptor.call(this, eventBus);
28596
 this._elementRegistry = elementRegistry;
 this._modeling = modeling;
 this._rules = rules;
28600
 var self = this;
28602
 this.postExecuted([ 'shape.create' ], function(event) {
   var context = event.context,
       hints = context.hints || {},
       shape = context.shape,
       parent = context.parent || context.newParent;
28608
   if (hints.autoResize === false) {
     return;
   }
28612
   self._expand([ shape ], parent);
 });
28615
 this.postExecuted([ 'elements.move' ], function(event) {
   var context = event.context,
       elements = flatten(values(context.closure.topLevel)),
       hints = context.hints;
28620
   var autoResize = hints ? hints.autoResize : true;
28622
   if (autoResize === false) {
     return;
   }
28626
   var expandings = groupBy(elements, function(element) {
     return element.parent.id;
   });
28630
   forEach$2(expandings, function(elements, parentId) {
28632
     // optionally filter elements to be considered when resizing
     if (isArray$4(autoResize)) {
       elements = elements.filter(function(element) {
         return find(autoResize, matchPattern({ id: element.id }));
       });
     }
28639
     self._expand(elements, parentId);
   });
 });
28643
 this.postExecuted([ 'shape.toggleCollapse' ], function(event) {
   var context = event.context,
       hints = context.hints,
       shape = context.shape;
28648
   if (hints && hints.autoResize === false) {
     return;
   }
28652
   if (shape.collapsed) {
     return;
   }
28656
   self._expand(shape.children || [], shape);
 });
28659
 this.postExecuted([ 'shape.resize' ], function(event) {
   var context = event.context,
       hints = context.hints,
       shape = context.shape,
       parent = shape.parent;
28665
   if (hints && hints.autoResize === false) {
     return;
   }
28669
   if (parent) {
     self._expand([ shape ], parent);
   }
 });
28674
}
28676
AutoResize.$inject = [
 'eventBus',
 'elementRegistry',
 'modeling',
 'rules'
];
28683
inherits$1(AutoResize, CommandInterceptor);
28685
28686
/**
* Calculate the new bounds of the target shape, given
* a number of elements have been moved or added into the parent.
*
* This method considers the current size, the added elements as well as
* the provided padding for the new bounds.
*
* @param {Array<djs.model.Shape>} elements
* @param {djs.model.Shape} target
*/
AutoResize.prototype._getOptimalBounds = function(elements, target) {
28698
 var offset = this.getOffset(target),
     padding = this.getPadding(target);
28701
 var elementsTrbl = asTRBL(getBBox(elements)),
     targetTrbl = asTRBL(target);
28704
 var newTrbl = {};
28706
 if (elementsTrbl.top - targetTrbl.top < padding.top) {
   newTrbl.top = elementsTrbl.top - offset.top;
 }
28710
 if (elementsTrbl.left - targetTrbl.left < padding.left) {
   newTrbl.left = elementsTrbl.left - offset.left;
 }
28714
 if (targetTrbl.right - elementsTrbl.right < padding.right) {
   newTrbl.right = elementsTrbl.right + offset.right;
 }
28718
 if (targetTrbl.bottom - elementsTrbl.bottom < padding.bottom) {
   newTrbl.bottom = elementsTrbl.bottom + offset.bottom;
 }
28722
 return asBounds(assign({}, targetTrbl, newTrbl));
};
28725
28726
/**
* Expand the target shape respecting rules, offset and padding
*
* @param {Array<djs.model.Shape>} elements
* @param {djs.model.Shape|string} target|targetId
*/
AutoResize.prototype._expand = function(elements, target) {
28734
 if (typeof target === 'string') {
   target = this._elementRegistry.get(target);
 }
28738
 var allowed = this._rules.allowed('element.autoResize', {
   elements: elements,
   target: target
 });
28743
 if (!allowed) {
   return;
 }
28747
 // calculate the new bounds
 var newBounds = this._getOptimalBounds(elements, target);
28750
 if (!boundsChanged$1(newBounds, target)) {
   return;
 }
28754
 var resizeDirections = getResizeDirections(pick(target, [ 'x', 'y', 'width', 'height' ]), newBounds);
28756
 // resize the parent shape
 this.resize(target, newBounds, {
   autoResize: resizeDirections
 });
28761
 var parent = target.parent;
28763
 // recursively expand parent elements
 if (parent) {
   this._expand([ target ], parent);
 }
};
28769
28770
/**
* Get the amount to expand the given shape in each direction.
*
* @param {djs.model.Shape} shape
*
* @return {TRBL}
*/
AutoResize.prototype.getOffset = function(shape) {
 return { top: 60, bottom: 60, left: 100, right: 100 };
};
28781
28782
/**
* Get the activation threshold for each side for which
* resize triggers.
*
* @param {djs.model.Shape} shape
*
* @return {TRBL}
*/
AutoResize.prototype.getPadding = function(shape) {
 return { top: 2, bottom: 2, left: 15, right: 15 };
};
28794
28795
/**
* Perform the actual resize operation.
*
* @param {djs.model.Shape} shape
* @param {Bounds} newBounds
* @param {Object} [hints]
* @param {string} [hints.autoResize]
*/
AutoResize.prototype.resize = function(shape, newBounds, hints) {
 this._modeling.resizeShape(shape, newBounds, null, hints);
};
28807
28808
function boundsChanged$1(newBounds, oldBounds) {
 return (
   newBounds.x !== oldBounds.x ||
   newBounds.y !== oldBounds.y ||
   newBounds.width !== oldBounds.width ||
   newBounds.height !== oldBounds.height
 );
}
28817
/**
* Get directions of resize as {n|w|s|e} e.g. "nw".
*
* @param {Bounds} oldBounds
* @param {Bounds} newBounds
*
* @returns {string} Resize directions as {n|w|s|e}.
*/
function getResizeDirections(oldBounds, newBounds) {
 var directions = '';
28828
 oldBounds = asTRBL(oldBounds);
 newBounds = asTRBL(newBounds);
28831
 if (oldBounds.top > newBounds.top) {
   directions = directions.concat('n');
 }
28835
 if (oldBounds.right < newBounds.right) {
   directions = directions.concat('w');
 }
28839
 if (oldBounds.bottom < newBounds.bottom) {
   directions = directions.concat('s');
 }
28843
 if (oldBounds.left > newBounds.left) {
   directions = directions.concat('e');
 }
28847
 return directions;
}
28850
/**
* Sub class of the AutoResize module which implements a BPMN
* specific resize function.
*/
function BpmnAutoResize(injector) {
28856
 injector.invoke(AutoResize, this);
}
28859
BpmnAutoResize.$inject = [
 'injector'
];
28863
inherits$1(BpmnAutoResize, AutoResize);
28865
28866
/**
* Resize shapes and lanes.
*
* @param {djs.model.Shape} target
* @param {Bounds} newBounds
* @param {Object} hints
*/
BpmnAutoResize.prototype.resize = function(target, newBounds, hints) {
28875
 if (is$1(target, 'bpmn:Participant')) {
   this._modeling.resizeLane(target, newBounds, null, hints);
 } else {
   this._modeling.resizeShape(target, newBounds, null, hints);
 }
};
28882
/**
* A basic provider that may be extended to implement modeling rules.
*
* Extensions should implement the init method to actually add their custom
* modeling checks. Checks may be added via the #addRule(action, fn) method.
*
* @param {EventBus} eventBus
*/
function RuleProvider(eventBus) {
 CommandInterceptor.call(this, eventBus);
28893
 this.init();
}
28896
RuleProvider.$inject = [ 'eventBus' ];
28898
inherits$1(RuleProvider, CommandInterceptor);
28900
28901
/**
* Adds a modeling rule for the given action, implemented through
* a callback function.
*
* The function will receive the modeling specific action context
* to perform its check. It must return `false` to disallow the
* action from happening or `true` to allow the action.
*
* A rule provider may pass over the evaluation to lower priority
* rules by returning return nothing (or <code>undefined</code>).
*
* @example
*
* ResizableRules.prototype.init = function() {
*
*   \/**
*    * Return `true`, `false` or nothing to denote
*    * _allowed_, _not allowed_ and _continue evaluating_.
*    *\/
*   this.addRule('shape.resize', function(context) {
*
*     var shape = context.shape;
*
*     if (!context.newBounds) {
*       // check general resizability
*       if (!shape.resizable) {
*         return false;
*       }
*
*       // not returning anything (read: undefined)
*       // will continue the evaluation of other rules
*       // (with lower priority)
*       return;
*     } else {
*       // element must have minimum size of 10*10 points
*       return context.newBounds.width > 10 && context.newBounds.height > 10;
*     }
*   });
* };
*
* @param {string|Array<string>} actions the identifier for the modeling action to check
* @param {number} [priority] the priority at which this rule is being applied
* @param {Function} fn the callback function that performs the actual check
*/
RuleProvider.prototype.addRule = function(actions, priority, fn) {
28947
 var self = this;
28949
 if (typeof actions === 'string') {
   actions = [ actions ];
 }
28953
 actions.forEach(function(action) {
28955
   self.canExecute(action, priority, function(context, action, event) {
     return fn(context);
   }, true);
 });
};
28961
/**
* Implement this method to add new rules during provider initialization.
*/
RuleProvider.prototype.init = function() {};
28966
/**
* This is a base rule provider for the element.autoResize rule.
*/
function AutoResizeProvider(eventBus) {
28971
 RuleProvider.call(this, eventBus);
28973
 var self = this;
28975
 this.addRule('element.autoResize', function(context) {
   return self.canResize(context.elements, context.target);
 });
}
28980
AutoResizeProvider.$inject = [ 'eventBus' ];
28982
inherits$1(AutoResizeProvider, RuleProvider);
28984
/**
* Needs to be implemented by sub classes to allow actual auto resize
*
* @param  {Array<djs.model.Shape>} elements
* @param  {djs.model.Shape} target
*
* @return {boolean}
*/
AutoResizeProvider.prototype.canResize = function(elements, target) {
 return false;
};
28996
/**
* This module is a provider for automatically resizing parent BPMN elements
*/
function BpmnAutoResizeProvider(eventBus, modeling) {
 AutoResizeProvider.call(this, eventBus);
29002
 this._modeling = modeling;
}
29005
inherits$1(BpmnAutoResizeProvider, AutoResizeProvider);
29007
BpmnAutoResizeProvider.$inject = [
 'eventBus',
 'modeling'
];
29012
29013
/**
* Check if the given target can be expanded
*
* @param  {djs.model.Shape} target
*
* @return {boolean}
*/
BpmnAutoResizeProvider.prototype.canResize = function(elements, target) {
29022
 // do not resize plane elements:
 // root elements, collapsed sub-processes
 if (is$1(target.di, 'bpmndi:BPMNPlane')) {
   return false;
 }
29028
 if (!is$1(target, 'bpmn:Participant') && !is$1(target, 'bpmn:Lane') && !(is$1(target, 'bpmn:SubProcess'))) {
   return false;
 }
29032
 var canResize = true;
29034
 forEach$2(elements, function(element) {
29036
   if (is$1(element, 'bpmn:Lane') || element.labelTarget) {
     canResize = false;
     return;
   }
 });
29042
 return canResize;
};
29045
var AutoResizeModule = {
 __init__: [
   'bpmnAutoResize',
   'bpmnAutoResizeProvider'
 ],
 bpmnAutoResize: [ 'type', BpmnAutoResize ],
 bpmnAutoResizeProvider: [ 'type', BpmnAutoResizeProvider ]
};
29054
var HIGH_PRIORITY$k = 1500;
29056
29057
/**
* Browsers may swallow certain events (hover, out ...) if users are to
* fast with the mouse.
*
* @see http://stackoverflow.com/questions/7448468/why-cant-i-reliably-capture-a-mouseout-event
*
* The fix implemented in this component ensure that we
*
* 1) have a hover state after a successful drag.move event
* 2) have an out event when dragging leaves an element
*
* @param {ElementRegistry} elementRegistry
* @param {EventBus} eventBus
* @param {Injector} injector
*/
function HoverFix(elementRegistry, eventBus, injector) {
29074
 var self = this;
29076
 var dragging = injector.get('dragging', false);
29078
 /**
  * Make sure we are god damn hovering!
  *
  * @param {Event} dragging event
  */
 function ensureHover(event) {
29085
   if (event.hover) {
     return;
   }
29089
   var originalEvent = event.originalEvent;
29091
   var gfx = self._findTargetGfx(originalEvent);
29093
   var element = gfx && elementRegistry.get(gfx);
29095
   if (gfx && element) {
29097
     // 1) cancel current mousemove
     event.stopPropagation();
29100
     // 2) emit fake hover for new target
     dragging.hover({ element: element, gfx: gfx });
29103
     // 3) re-trigger move event
     dragging.move(originalEvent);
   }
 }
29108
29109
 if (dragging) {
29111
   /**
    * We wait for a specific sequence of events before
    * emitting a fake drag.hover event.
    *
    * Event Sequence:
    *
    * drag.start
    * drag.move >> ensure we are hovering
    */
   eventBus.on('drag.start', function(event) {
29122
     eventBus.once('drag.move', HIGH_PRIORITY$k, function(event) {
29124
       ensureHover(event);
29126
     });
29128
   });
 }
29131
29132
 /**
  * We make sure that element.out is always fired, even if the
  * browser swallows an element.out event.
  *
  * Event sequence:
  *
  * element.hover
  * (element.out >> sometimes swallowed)
  * element.hover >> ensure we fired element.out
  */
 (function() {
   var hoverGfx;
   var hover;
29146
   eventBus.on('element.hover', function(event) {
29148
     // (1) remember current hover element
     hoverGfx = event.gfx;
     hover = event.element;
   });
29153
   eventBus.on('element.hover', HIGH_PRIORITY$k, function(event) {
29155
     // (3) am I on an element still?
     if (hover) {
29158
       // (4) that is a problem, gotta "simulate the out"
       eventBus.fire('element.out', {
         element: hover,
         gfx: hoverGfx
       });
     }
29165
   });
29167
   eventBus.on('element.out', function() {
29169
     // (2) unset hover state if we correctly outed us *GG*
     hoverGfx = null;
     hover = null;
   });
29174
 })();
29176
 this._findTargetGfx = function(event) {
   var position,
       target;
29180
   if (!(event instanceof MouseEvent)) {
     return;
   }
29184
   position = toPoint(event);
29186
   // damn expensive operation, ouch!
   target = document.elementFromPoint(position.x, position.y);
29189
   return getGfx(target);
 };
29192
}
29194
HoverFix.$inject = [
 'elementRegistry',
 'eventBus',
 'injector'
];
29200
29201
// helpers /////////////////////
29203
function getGfx(target) {
 return closest(target, 'svg, .djs-element', true);
}
29207
var HoverFixModule = {
 __init__: [
   'hoverFix'
 ],
 hoverFix: [ 'type', HoverFix ],
};
29214
var round$a = Math.round;
29216
var DRAG_ACTIVE_CLS = 'djs-drag-active';
29218
29219
function preventDefault$1(event) {
 event.preventDefault();
}
29223
function isTouchEvent(event) {
29225
 // check for TouchEvent being available first
 // (i.e. not available on desktop Firefox)
 return typeof TouchEvent !== 'undefined' && event instanceof TouchEvent;
}
29230
function getLength(point) {
 return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
}
29234
/**
* A helper that fires canvas localized drag events and realizes
* the general "drag-and-drop" look and feel.
*
* Calling {@link Dragging#activate} activates dragging on a canvas.
*
* It provides the following:
*
*   * emits life cycle events, namespaced with a prefix assigned
*     during dragging activation
*   * sets and restores the cursor
*   * sets and restores the selection if elements still exist
*   * ensures there can be only one drag operation active at a time
*
* Dragging may be canceled manually by calling {@link Dragging#cancel}
* or by pressing ESC.
*
*
* ## Life-cycle events
*
* Dragging can be in three different states, off, initialized
* and active.
*
* (1) off: no dragging operation is in progress
* (2) initialized: a new drag operation got initialized but not yet
*                  started (i.e. because of no initial move)
* (3) started: dragging is in progress
*
* Eventually dragging will be off again after a drag operation has
* been ended or canceled via user click or ESC key press.
*
* To indicate transitions between these states dragging emits generic
* life-cycle events with the `drag.` prefix _and_ events namespaced
* to a prefix choosen by a user during drag initialization.
*
* The following events are emitted (appropriately prefixed) via
* the {@link EventBus}.
*
* * `init`
* * `start`
* * `move`
* * `end`
* * `ended` (dragging already in off state)
* * `cancel` (only if previously started)
* * `canceled` (dragging already in off state, only if previously started)
* * `cleanup`
*
*
* @example
*
* function MyDragComponent(eventBus, dragging) {
*
*   eventBus.on('mydrag.start', function(event) {
*     console.log('yes, we start dragging');
*   });
*
*   eventBus.on('mydrag.move', function(event) {
*     console.log('canvas local coordinates', event.x, event.y, event.dx, event.dy);
*
*     // local drag data is passed with the event
*     event.context.foo; // "BAR"
*
*     // the original mouse event, too
*     event.originalEvent; // MouseEvent(...)
*   });
*
*   eventBus.on('element.click', function(event) {
*     dragging.init(event, 'mydrag', {
*       cursor: 'grabbing',
*       data: {
*         context: {
*           foo: "BAR"
*         }
*       }
*     });
*   });
* }
*/
function Dragging(eventBus, canvas, selection, elementRegistry) {
29314
 var defaultOptions = {
   threshold: 5,
   trapClick: true
 };
29319
 // the currently active drag operation
 // dragging is active as soon as this context exists.
 //
 // it is visually _active_ only when a context.active flag is set to true.
 var context;
29325
 /* convert a global event into local coordinates */
 function toLocalPoint(globalPosition) {
29328
   var viewbox = canvas.viewbox();
29330
   var clientRect = canvas._container.getBoundingClientRect();
29332
   return {
     x: viewbox.x + (globalPosition.x - clientRect.left) / viewbox.scale,
     y: viewbox.y + (globalPosition.y - clientRect.top) / viewbox.scale
   };
 }
29338
 // helpers
29340
 function fire(type, dragContext) {
   dragContext = dragContext || context;
29343
   var event = eventBus.createEvent(
     assign(
       {},
       dragContext.payload,
       dragContext.data,
       { isTouch: dragContext.isTouch }
     )
   );
29352
   // default integration
   if (eventBus.fire('drag.' + type, event) === false) {
     return false;
   }
29357
   return eventBus.fire(dragContext.prefix + '.' + type, event);
 }
29360
 function restoreSelection(previousSelection) {
   var existingSelection = previousSelection.filter(function(element) {
     return elementRegistry.get(element.id);
   });
29365
   existingSelection.length && selection.select(existingSelection);
 }
29368
 // event listeners
29370
 function move(event, activate) {
   var payload = context.payload,
       displacement = context.displacement;
29374
   var globalStart = context.globalStart,
       globalCurrent = toPoint(event),
       globalDelta = delta(globalCurrent, globalStart);
29378
   var localStart = context.localStart,
       localCurrent = toLocalPoint(globalCurrent),
       localDelta = delta(localCurrent, localStart);
29382
29383
   // activate context explicitly or once threshold is reached
   if (!context.active && (activate || getLength(globalDelta) > context.threshold)) {
29386
     // fire start event with original
     // starting coordinates
29389
     assign(payload, {
       x: round$a(localStart.x + displacement.x),
       y: round$a(localStart.y + displacement.y),
       dx: 0,
       dy: 0
     }, { originalEvent: event });
29396
     if (false === fire('start')) {
       return cancel();
     }
29400
     context.active = true;
29402
     // unset selection and remember old selection
     // the previous (old) selection will always passed
     // with the event via the event.previousSelection property
     if (!context.keepSelection) {
       payload.previousSelection = selection.get();
       selection.select(null);
     }
29410
     // allow custom cursor
     if (context.cursor) {
       set(context.cursor);
     }
29415
     // indicate dragging via marker on root element
     canvas.addMarker(canvas.getRootElement(), DRAG_ACTIVE_CLS);
   }
29419
   stopPropagation$1(event);
29421
   if (context.active) {
29423
     // update payload with actual coordinates
     assign(payload, {
       x: round$a(localCurrent.x + displacement.x),
       y: round$a(localCurrent.y + displacement.y),
       dx: round$a(localDelta.x),
       dy: round$a(localDelta.y)
     }, { originalEvent: event });
29431
     // emit move event
     fire('move');
   }
 }
29436
 function end(event) {
   var previousContext,
       returnValue = true;
29440
   if (context.active) {
29442
     if (event) {
       context.payload.originalEvent = event;
29445
       // suppress original event (click, ...)
       // because we just ended a drag operation
       stopPropagation$1(event);
     }
29450
     // implementations may stop restoring the
     // original state (selections, ...) by preventing the
     // end events default action
     returnValue = fire('end');
   }
29456
   if (returnValue === false) {
     fire('rejected');
   }
29460
   previousContext = cleanup(returnValue !== true);
29462
   // last event to be fired when all drag operations are done
   // at this point in time no drag operation is in progress anymore
   fire('ended', previousContext);
 }
29467
29468
 // cancel active drag operation if the user presses
 // the ESC key on the keyboard
29471
 function checkCancel(event) {
29473
   if (event.which === 27) {
     preventDefault$1(event);
29476
     cancel();
   }
 }
29480
29481
 // prevent ghost click that might occur after a finished
 // drag and drop session
29484
 function trapClickAndEnd(event) {
29486
   var untrap;
29488
   // trap the click in case we are part of an active
   // drag operation. This will effectively prevent
   // the ghost click that cannot be canceled otherwise.
   if (context.active) {
29493
     untrap = install(eventBus);
29495
     // remove trap after minimal delay
     setTimeout(untrap, 400);
29498
     // prevent default action (click)
     preventDefault$1(event);
   }
29502
   end(event);
 }
29505
 function trapTouch(event) {
   move(event);
 }
29509
 // update the drag events hover (djs.model.Base) and hoverGfx (Snap<SVGElement>)
 // properties during hover and out and fire {prefix}.hover and {prefix}.out properties
 // respectively
29513
 function hover(event) {
   var payload = context.payload;
29516
   payload.hoverGfx = event.gfx;
   payload.hover = event.element;
29519
   fire('hover');
 }
29522
 function out(event) {
   fire('out');
29525
   var payload = context.payload;
29527
   payload.hoverGfx = null;
   payload.hover = null;
 }
29531
29532
 // life-cycle methods
29534
 function cancel(restore) {
   var previousContext;
29537
   if (!context) {
     return;
   }
29541
   var wasActive = context.active;
29543
   if (wasActive) {
     fire('cancel');
   }
29547
   previousContext = cleanup(restore);
29549
   if (wasActive) {
29551
     // last event to be fired when all drag operations are done
     // at this point in time no drag operation is in progress anymore
     fire('canceled', previousContext);
   }
 }
29557
 function cleanup(restore) {
   var previousContext,
       endDrag;
29561
   fire('cleanup');
29563
   // reset cursor
   unset();
29566
   if (context.trapClick) {
     endDrag = trapClickAndEnd;
   } else {
     endDrag = end;
   }
29572
   // reset dom listeners
   componentEvent.unbind(document, 'mousemove', move);
29575
   componentEvent.unbind(document, 'dragstart', preventDefault$1);
   componentEvent.unbind(document, 'selectstart', preventDefault$1);
29578
   componentEvent.unbind(document, 'mousedown', endDrag, true);
   componentEvent.unbind(document, 'mouseup', endDrag, true);
29581
   componentEvent.unbind(document, 'keyup', checkCancel);
29583
   componentEvent.unbind(document, 'touchstart', trapTouch, true);
   componentEvent.unbind(document, 'touchcancel', cancel, true);
   componentEvent.unbind(document, 'touchmove', move, true);
   componentEvent.unbind(document, 'touchend', end, true);
29588
   eventBus.off('element.hover', hover);
   eventBus.off('element.out', out);
29591
   // remove drag marker on root element
   canvas.removeMarker(canvas.getRootElement(), DRAG_ACTIVE_CLS);
29594
   // restore selection, unless it has changed
   var previousSelection = context.payload.previousSelection;
29597
   if (restore !== false && previousSelection && !selection.get().length) {
     restoreSelection(previousSelection);
   }
29601
   previousContext = context;
29603
   context = null;
29605
   return previousContext;
 }
29608
 /**
  * Initialize a drag operation.
  *
  * If `localPosition` is given, drag events will be emitted
  * relative to it.
  *
  * @param {MouseEvent|TouchEvent} [event]
  * @param {Point} [localPosition] actual diagram local position this drag operation should start at
  * @param {string} prefix
  * @param {Object} [options]
  */
 function init(event, relativeTo, prefix, options) {
29621
   // only one drag operation may be active, at a time
   if (context) {
     cancel(false);
   }
29626
   if (typeof relativeTo === 'string') {
     options = prefix;
     prefix = relativeTo;
     relativeTo = null;
   }
29632
   options = assign({}, defaultOptions, options || {});
29634
   var data = options.data || {},
       originalEvent,
       globalStart,
       localStart,
       endDrag,
       isTouch;
29641
   if (options.trapClick) {
     endDrag = trapClickAndEnd;
   } else {
     endDrag = end;
   }
29647
   if (event) {
     originalEvent = getOriginal$1(event) || event;
     globalStart = toPoint(event);
29651
     stopPropagation$1(event);
29653
     // prevent default browser dragging behavior
     if (originalEvent.type === 'dragstart') {
       preventDefault$1(originalEvent);
     }
   } else {
     originalEvent = null;
     globalStart = { x: 0, y: 0 };
   }
29662
   localStart = toLocalPoint(globalStart);
29664
   if (!relativeTo) {
     relativeTo = localStart;
   }
29668
   isTouch = isTouchEvent(originalEvent);
29670
   context = assign({
     prefix: prefix,
     data: data,
     payload: {},
     globalStart: globalStart,
     displacement: delta(relativeTo, localStart),
     localStart: localStart,
     isTouch: isTouch
   }, options);
29680
   // skip dom registration if trigger
   // is set to manual (during testing)
   if (!options.manual) {
29684
     // add dom listeners
29686
     if (isTouch) {
       componentEvent.bind(document, 'touchstart', trapTouch, true);
       componentEvent.bind(document, 'touchcancel', cancel, true);
       componentEvent.bind(document, 'touchmove', move, true);
       componentEvent.bind(document, 'touchend', end, true);
     } else {
29693
       // assume we use the mouse to interact per default
       componentEvent.bind(document, 'mousemove', move);
29696
       // prevent default browser drag and text selection behavior
       componentEvent.bind(document, 'dragstart', preventDefault$1);
       componentEvent.bind(document, 'selectstart', preventDefault$1);
29700
       componentEvent.bind(document, 'mousedown', endDrag, true);
       componentEvent.bind(document, 'mouseup', endDrag, true);
     }
29704
     componentEvent.bind(document, 'keyup', checkCancel);
29706
     eventBus.on('element.hover', hover);
     eventBus.on('element.out', out);
   }
29710
   fire('init');
29712
   if (options.autoActivate) {
     move(event, true);
   }
 }
29717
 // cancel on diagram destruction
 eventBus.on('diagram.destroy', cancel);
29720
29721
 // API
29723
 this.init = init;
 this.move = move;
 this.hover = hover;
 this.out = out;
 this.end = end;
29729
 this.cancel = cancel;
29731
 // for introspection
29733
 this.context = function() {
   return context;
 };
29737
 this.setOptions = function(options) {
   assign(defaultOptions, options);
 };
}
29742
Dragging.$inject = [
 'eventBus',
 'canvas',
 'selection',
 'elementRegistry'
];
29749
var DraggingModule = {
 __depends__: [
   HoverFixModule,
   SelectionModule,
 ],
 dragging: [ 'type', Dragging ],
};
29757
/**
* Initiates canvas scrolling if current cursor point is close to a border.
* Cancelled when current point moves back inside the scrolling borders
* or cancelled manually.
*
* Default options :
*   scrollThresholdIn: [ 20, 20, 20, 20 ],
*   scrollThresholdOut: [ 0, 0, 0, 0 ],
*   scrollRepeatTimeout: 15,
*   scrollStep: 10
*
* Threshold order:
*   [ left, top, right, bottom ]
*/
function AutoScroll(config, eventBus, canvas) {
29773
 this._canvas = canvas;
29775
 this._opts = assign({
   scrollThresholdIn: [ 20, 20, 20, 20 ],
   scrollThresholdOut: [ 0, 0, 0, 0 ],
   scrollRepeatTimeout: 15,
   scrollStep: 10
 }, config);
29782
 var self = this;
29784
 eventBus.on('drag.move', function(e) {
   var point = self._toBorderPoint(e);
29787
   self.startScroll(point);
 });
29790
 eventBus.on([ 'drag.cleanup' ], function() {
   self.stopScroll();
 });
}
29795
AutoScroll.$inject = [
 'config.autoScroll',
 'eventBus',
 'canvas'
];
29801
29802
/**
* Starts scrolling loop.
* Point is given in global scale in canvas container box plane.
*
* @param  {Object} point { x: X, y: Y }
*/
AutoScroll.prototype.startScroll = function(point) {
29810
 var canvas = this._canvas;
 var opts = this._opts;
 var self = this;
29814
 var clientRect = canvas.getContainer().getBoundingClientRect();
29816
 var diff = [
   point.x,
   point.y,
   clientRect.width - point.x,
   clientRect.height - point.y
 ];
29823
 this.stopScroll();
29825
 var dx = 0,
     dy = 0;
29828
 for (var i = 0; i < 4; i++) {
   if (between(diff[i], opts.scrollThresholdOut[i], opts.scrollThresholdIn[i])) {
     if (i === 0) {
       dx = opts.scrollStep;
     } else if (i == 1) {
       dy = opts.scrollStep;
     } else if (i == 2) {
       dx = -opts.scrollStep;
     } else if (i == 3) {
       dy = -opts.scrollStep;
     }
   }
 }
29842
 if (dx !== 0 || dy !== 0) {
   canvas.scroll({ dx: dx, dy: dy });
29845
   this._scrolling = setTimeout(function() {
     self.startScroll(point);
   }, opts.scrollRepeatTimeout);
 }
};
29851
function between(val, start, end) {
 if (start < val && val < end) {
   return true;
 }
29856
 return false;
}
29859
29860
/**
* Stops scrolling loop.
*/
AutoScroll.prototype.stopScroll = function() {
 clearTimeout(this._scrolling);
};
29867
29868
/**
* Overrides defaults options.
*
* @param  {Object} options
*/
AutoScroll.prototype.setOptions = function(options) {
 this._opts = assign({}, this._opts, options);
};
29877
29878
/**
* Converts event to a point in canvas container plane in global scale.
*
* @param  {Event} event
* @return {Point}
*/
AutoScroll.prototype._toBorderPoint = function(event) {
 var clientRect = this._canvas._container.getBoundingClientRect();
29887
 var globalPosition = toPoint(event.originalEvent);
29889
 return {
   x: globalPosition.x - clientRect.left,
   y: globalPosition.y - clientRect.top
 };
};
29895
var AutoScrollModule = {
 __depends__: [
   DraggingModule,
 ],
 __init__: [ 'autoScroll' ],
 autoScroll: [ 'type', AutoScroll ]
};
29903
/**
* A service that provides rules for certain diagram actions.
*
* The default implementation will hook into the {@link CommandStack}
* to perform the actual rule evaluation. Make sure to provide the
* `commandStack` service with this module if you plan to use it.
*
* Together with this implementation you may use the {@link RuleProvider}
* to implement your own rule checkers.
*
* This module is ment to be easily replaced, thus the tiny foot print.
*
* @param {Injector} injector
*/
function Rules(injector) {
 this._commandStack = injector.get('commandStack', false);
}
29921
Rules.$inject = [ 'injector' ];
29923
29924
/**
* Returns whether or not a given modeling action can be executed
* in the specified context.
*
* This implementation will respond with allow unless anyone
* objects.
*
* @param {string} action the action to be checked
* @param {Object} [context] the context to check the action in
*
* @return {boolean} returns true, false or null depending on whether the
*                   operation is allowed, not allowed or should be ignored.
*/
Rules.prototype.allowed = function(action, context) {
 var allowed = true;
29940
 var commandStack = this._commandStack;
29942
 if (commandStack) {
   allowed = commandStack.canExecute(action, context);
 }
29946
 // map undefined to true, i.e. no rules
 return allowed === undefined ? true : allowed;
};
29950
var RulesModule$1 = {
 __init__: [ 'rules' ],
 rules: [ 'type', Rules ]
};
29955
var round$9 = Math.round,
   max$6 = Math.max;
29958
29959
function circlePath(center, r) {
 var x = center.x,
     y = center.y;
29963
 return [
   [ 'M', x, y ],
   [ 'm', 0, -r ],
   [ 'a', r, r, 0, 1, 1, 0, 2 * r ],
   [ 'a', r, r, 0, 1, 1, 0, -2 * r ],
   [ 'z' ]
 ];
}
29972
function linePath(points) {
 var segments = [];
29975
 points.forEach(function(p, idx) {
   segments.push([ idx === 0 ? 'M' : 'L', p.x, p.y ]);
 });
29979
 return segments;
}
29982
29983
var INTERSECTION_THRESHOLD$1 = 10;
29985
function getBendpointIntersection(waypoints, reference) {
29987
 var i, w;
29989
 for (i = 0; (w = waypoints[i]); i++) {
29991
   if (pointDistance(w, reference) <= INTERSECTION_THRESHOLD$1) {
     return {
       point: waypoints[i],
       bendpoint: true,
       index: i
     };
   }
 }
30000
 return null;
}
30003
function getPathIntersection(waypoints, reference) {
30005
 var intersections = intersect(circlePath(reference, INTERSECTION_THRESHOLD$1), linePath(waypoints));
30007
 var a = intersections[0],
     b = intersections[intersections.length - 1],
     idx;
30011
 if (!a) {
30013
   // no intersection
   return null;
 }
30017
 if (a !== b) {
30019
   if (a.segment2 !== b.segment2) {
30021
     // we use the bendpoint in between both segments
     // as the intersection point
30024
     idx = max$6(a.segment2, b.segment2) - 1;
30026
     return {
       point: waypoints[idx],
       bendpoint: true,
       index: idx
     };
   }
30033
   return {
     point: {
       x: (round$9(a.x + b.x) / 2),
       y: (round$9(a.y + b.y) / 2)
     },
     index: a.segment2
   };
 }
30042
 return {
   point: {
     x: round$9(a.x),
     y: round$9(a.y)
   },
   index: a.segment2
 };
}
30051
/**
* Returns the closest point on the connection towards a given reference point.
*
* @param  {Array<Point>} waypoints
* @param  {Point} reference
*
* @return {Object} intersection data (segment, point)
*/
function getApproxIntersection(waypoints, reference) {
 return getBendpointIntersection(waypoints, reference) || getPathIntersection(waypoints, reference);
}
30063
var BENDPOINT_CLS = 'djs-bendpoint';
var SEGMENT_DRAGGER_CLS = 'djs-segment-dragger';
30066
function toCanvasCoordinates(canvas, event) {
30068
 var position = toPoint(event),
     clientRect = canvas._container.getBoundingClientRect(),
     offset;
30072
 // canvas relative position
30074
 offset = {
   x: clientRect.left,
   y: clientRect.top
 };
30079
 // update actual event payload with canvas relative measures
30081
 var viewbox = canvas.viewbox();
30083
 return {
   x: viewbox.x + (position.x - offset.x) / viewbox.scale,
   y: viewbox.y + (position.y - offset.y) / viewbox.scale
 };
}
30089
function getConnectionIntersection(canvas, waypoints, event) {
 var localPosition = toCanvasCoordinates(canvas, event),
     intersection = getApproxIntersection(waypoints, localPosition);
30093
 return intersection;
}
30096
function addBendpoint(parentGfx, cls) {
 var groupGfx = create$1('g');
 classes$1(groupGfx).add(BENDPOINT_CLS);
30100
 append(parentGfx, groupGfx);
30102
 var visual = create$1('circle');
 attr$1(visual, {
   cx: 0,
   cy: 0,
   r: 4
 });
 classes$1(visual).add('djs-visual');
30110
 append(groupGfx, visual);
30112
 var hit = create$1('circle');
 attr$1(hit, {
   cx: 0,
   cy: 0,
   r: 10
 });
 classes$1(hit).add('djs-hit');
30120
 append(groupGfx, hit);
30122
 if (cls) {
   classes$1(groupGfx).add(cls);
 }
30126
 return groupGfx;
}
30129
function createParallelDragger(parentGfx, segmentStart, segmentEnd, alignment) {
 var draggerGfx = create$1('g');
30132
 append(parentGfx, draggerGfx);
30134
 var width = 14,
     height = 3,
     padding = 11,
     hitWidth = calculateHitWidth(segmentStart, segmentEnd, alignment),
     hitHeight = height + padding;
30140
 var visual = create$1('rect');
 attr$1(visual, {
   x: -width / 2,
   y: -height / 2,
   width: width,
   height: height
 });
 classes$1(visual).add('djs-visual');
30149
 append(draggerGfx, visual);
30151
 var hit = create$1('rect');
 attr$1(hit, {
   x: -hitWidth / 2,
   y: -hitHeight / 2,
   width: hitWidth,
   height: hitHeight
 });
 classes$1(hit).add('djs-hit');
30160
 append(draggerGfx, hit);
30162
 rotate(draggerGfx, alignment === 'v' ? 90 : 0);
30164
 return draggerGfx;
}
30167
30168
function addSegmentDragger(parentGfx, segmentStart, segmentEnd) {
30170
 var groupGfx = create$1('g'),
     mid = getMidPoint(segmentStart, segmentEnd),
     alignment = pointsAligned(segmentStart, segmentEnd);
30174
 append(parentGfx, groupGfx);
30176
 createParallelDragger(groupGfx, segmentStart, segmentEnd, alignment);
30178
 classes$1(groupGfx).add(SEGMENT_DRAGGER_CLS);
 classes$1(groupGfx).add(alignment === 'h' ? 'horizontal' : 'vertical');
30181
 translate$2(groupGfx, mid.x, mid.y);
30183
 return groupGfx;
}
30186
/**
* Calculates region for segment move which is 2/3 of the full segment length
* @param {number} segmentLength
*
* @return {number}
*/
function calculateSegmentMoveRegion(segmentLength) {
 return Math.abs(Math.round(segmentLength * 2 / 3));
}
30196
// helper //////////
30198
function calculateHitWidth(segmentStart, segmentEnd, alignment) {
 var segmentLengthXAxis = segmentEnd.x - segmentStart.x,
     segmentLengthYAxis = segmentEnd.y - segmentStart.y;
30202
 return alignment === 'h' ?
   calculateSegmentMoveRegion(segmentLengthXAxis) :
   calculateSegmentMoveRegion(segmentLengthYAxis);
}
30207
/**
* A service that adds editable bendpoints to connections.
*/
function Bendpoints(
   eventBus, canvas, interactionEvents,
   bendpointMove, connectionSegmentMove) {
30214
 /**
  * Returns true if intersection point is inside middle region of segment, adjusted by
  * optional threshold
  */
 function isIntersectionMiddle(intersection, waypoints, treshold) {
   var idx = intersection.index,
       p = intersection.point,
       p0, p1, mid, aligned, xDelta, yDelta;
30223
   if (idx <= 0 || intersection.bendpoint) {
     return false;
   }
30227
   p0 = waypoints[idx - 1];
   p1 = waypoints[idx];
   mid = getMidPoint(p0, p1),
   aligned = pointsAligned(p0, p1);
   xDelta = Math.abs(p.x - mid.x);
   yDelta = Math.abs(p.y - mid.y);
30234
   return aligned && xDelta <= treshold && yDelta <= treshold;
 }
30237
 /**
  * Calculates the threshold from a connection's middle which fits the two-third-region
  */
 function calculateIntersectionThreshold(connection, intersection) {
   var waypoints = connection.waypoints,
       relevantSegment, alignment, segmentLength, threshold;
30244
   if (intersection.index <= 0 || intersection.bendpoint) {
     return null;
   }
30248
   // segment relative to connection intersection
   relevantSegment = {
     start: waypoints[intersection.index - 1],
     end: waypoints[intersection.index]
   };
30254
   alignment = pointsAligned(relevantSegment.start, relevantSegment.end);
30256
   if (!alignment) {
     return null;
   }
30260
   if (alignment === 'h') {
     segmentLength = relevantSegment.end.x - relevantSegment.start.x;
   } else {
     segmentLength = relevantSegment.end.y - relevantSegment.start.y;
   }
30266
   // calculate threshold relative to 2/3 of segment length
   threshold = calculateSegmentMoveRegion(segmentLength) / 2;
30269
   return threshold;
 }
30272
 function activateBendpointMove(event, connection) {
   var waypoints = connection.waypoints,
       intersection = getConnectionIntersection(canvas, waypoints, event),
       threshold;
30277
   if (!intersection) {
     return;
   }
30281
   threshold = calculateIntersectionThreshold(connection, intersection);
30283
   if (isIntersectionMiddle(intersection, waypoints, threshold)) {
     connectionSegmentMove.start(event, connection, intersection.index);
   } else {
     bendpointMove.start(event, connection, intersection.index, !intersection.bendpoint);
   }
30289
   // we've handled the event
   return true;
 }
30293
 function bindInteractionEvents(node, eventName, element) {
30295
   componentEvent.bind(node, eventName, function(event) {
     interactionEvents.triggerMouseEvent(eventName, event, element);
     event.stopPropagation();
   });
 }
30301
 function getBendpointsContainer(element, create) {
30303
   var layer = canvas.getLayer('overlays'),
       gfx = query('.djs-bendpoints[data-element-id="' + cssEscape(element.id) + '"]', layer);
30306
   if (!gfx && create) {
     gfx = create$1('g');
     attr$1(gfx, { 'data-element-id': element.id });
     classes$1(gfx).add('djs-bendpoints');
30311
     append(layer, gfx);
30313
     bindInteractionEvents(gfx, 'mousedown', element);
     bindInteractionEvents(gfx, 'click', element);
     bindInteractionEvents(gfx, 'dblclick', element);
   }
30318
   return gfx;
 }
30321
 function getSegmentDragger(idx, parentGfx) {
   return query(
     '.djs-segment-dragger[data-segment-idx="' + idx + '"]',
     parentGfx
   );
 }
30328
 function createBendpoints(gfx, connection) {
   connection.waypoints.forEach(function(p, idx) {
     var bendpoint = addBendpoint(gfx);
30332
     append(gfx, bendpoint);
30334
     translate$2(bendpoint, p.x, p.y);
   });
30337
   // add floating bendpoint
   addBendpoint(gfx, 'floating');
 }
30341
 function createSegmentDraggers(gfx, connection) {
30343
   var waypoints = connection.waypoints;
30345
   var segmentStart,
       segmentEnd,
       segmentDraggerGfx;
30349
   for (var i = 1; i < waypoints.length; i++) {
30351
     segmentStart = waypoints[i - 1];
     segmentEnd = waypoints[i];
30354
     if (pointsAligned(segmentStart, segmentEnd)) {
       segmentDraggerGfx = addSegmentDragger(gfx, segmentStart, segmentEnd);
30357
       attr$1(segmentDraggerGfx, { 'data-segment-idx': i });
30359
       bindInteractionEvents(segmentDraggerGfx, 'mousemove', connection);
     }
   }
 }
30364
 function clearBendpoints(gfx) {
   forEach$2(all('.' + BENDPOINT_CLS, gfx), function(node) {
     remove$2(node);
   });
 }
30370
 function clearSegmentDraggers(gfx) {
   forEach$2(all('.' + SEGMENT_DRAGGER_CLS, gfx), function(node) {
     remove$2(node);
   });
 }
30376
 function addHandles(connection) {
30378
   var gfx = getBendpointsContainer(connection);
30380
   if (!gfx) {
     gfx = getBendpointsContainer(connection, true);
30383
     createBendpoints(gfx, connection);
     createSegmentDraggers(gfx, connection);
   }
30387
   return gfx;
 }
30390
 function updateHandles(connection) {
30392
   var gfx = getBendpointsContainer(connection);
30394
   if (gfx) {
     clearSegmentDraggers(gfx);
     clearBendpoints(gfx);
     createSegmentDraggers(gfx, connection);
     createBendpoints(gfx, connection);
   }
 }
30402
 function updateFloatingBendpointPosition(parentGfx, intersection) {
   var floating = query('.floating', parentGfx),
       point = intersection.point;
30406
   if (!floating) {
     return;
   }
30410
   translate$2(floating, point.x, point.y);
30412
 }
30414
 function updateSegmentDraggerPosition(parentGfx, intersection, waypoints) {
30416
   var draggerGfx = getSegmentDragger(intersection.index, parentGfx),
       segmentStart = waypoints[intersection.index - 1],
       segmentEnd = waypoints[intersection.index],
       point = intersection.point,
       mid = getMidPoint(segmentStart, segmentEnd),
       alignment = pointsAligned(segmentStart, segmentEnd),
       draggerVisual, relativePosition;
30424
   if (!draggerGfx) {
     return;
   }
30428
   draggerVisual = getDraggerVisual(draggerGfx);
30430
   relativePosition = {
     x: point.x - mid.x,
     y: point.y - mid.y
   };
30435
   if (alignment === 'v') {
30437
     // rotate position
     relativePosition = {
       x: relativePosition.y,
       y: relativePosition.x
     };
   }
30444
   translate$2(draggerVisual, relativePosition.x, relativePosition.y);
 }
30447
 eventBus.on('connection.changed', function(event) {
   updateHandles(event.element);
 });
30451
 eventBus.on('connection.remove', function(event) {
   var gfx = getBendpointsContainer(event.element);
30454
   if (gfx) {
     remove$2(gfx);
   }
 });
30459
 eventBus.on('element.marker.update', function(event) {
30461
   var element = event.element,
       bendpointsGfx;
30464
   if (!element.waypoints) {
     return;
   }
30468
   bendpointsGfx = addHandles(element);
30470
   if (event.add) {
     classes$1(bendpointsGfx).add(event.marker);
   } else {
     classes$1(bendpointsGfx).remove(event.marker);
   }
 });
30477
 eventBus.on('element.mousemove', function(event) {
30479
   var element = event.element,
       waypoints = element.waypoints,
       bendpointsGfx,
       intersection;
30484
   if (waypoints) {
     bendpointsGfx = getBendpointsContainer(element, true);
30487
     intersection = getConnectionIntersection(canvas, waypoints, event.originalEvent);
30489
     if (!intersection) {
       return;
     }
30493
     updateFloatingBendpointPosition(bendpointsGfx, intersection);
30495
     if (!intersection.bendpoint) {
       updateSegmentDraggerPosition(bendpointsGfx, intersection, waypoints);
     }
30499
   }
 });
30502
 eventBus.on('element.mousedown', function(event) {
30504
   if (!isPrimaryButton(event)) {
     return;
   }
30508
   var originalEvent = event.originalEvent,
       element = event.element;
30511
   if (!element.waypoints) {
     return;
   }
30515
   return activateBendpointMove(originalEvent, element);
 });
30518
 eventBus.on('selection.changed', function(event) {
   var newSelection = event.newSelection,
       primary = newSelection[0];
30522
   if (primary && primary.waypoints) {
     addHandles(primary);
   }
 });
30527
 eventBus.on('element.hover', function(event) {
   var element = event.element;
30530
   if (element.waypoints) {
     addHandles(element);
     interactionEvents.registerEvent(event.gfx, 'mousemove', 'element.mousemove');
   }
 });
30536
 eventBus.on('element.out', function(event) {
   interactionEvents.unregisterEvent(event.gfx, 'mousemove', 'element.mousemove');
 });
30540
 // update bendpoint container data attribute on element ID change
 eventBus.on('element.updateId', function(context) {
   var element = context.element,
       newId = context.newId;
30545
   if (element.waypoints) {
     var bendpointContainer = getBendpointsContainer(element);
30548
     if (bendpointContainer) {
       attr$1(bendpointContainer, { 'data-element-id': newId });
     }
   }
 });
30554
 // API
30556
 this.addHandles = addHandles;
 this.updateHandles = updateHandles;
 this.getBendpointsContainer = getBendpointsContainer;
 this.getSegmentDragger = getSegmentDragger;
}
30562
Bendpoints.$inject = [
 'eventBus',
 'canvas',
 'interactionEvents',
 'bendpointMove',
 'connectionSegmentMove'
];
30570
30571
30572
// helper /////////////
30574
function getDraggerVisual(draggerGfx) {
 return query('.djs-visual', draggerGfx);
}
30578
var round$8 = Math.round;
30580
var RECONNECT_START$1 = 'reconnectStart',
   RECONNECT_END$1 = 'reconnectEnd',
   UPDATE_WAYPOINTS$1 = 'updateWaypoints';
30584
30585
/**
* Move bendpoints through drag and drop to add/remove bendpoints or reconnect connection.
*/
function BendpointMove(injector, eventBus, canvas, dragging, rules, modeling) {
 this._injector = injector;
30591
 this.start = function(event, connection, bendpointIndex, insert) {
   var gfx = canvas.getGraphics(connection),
       source = connection.source,
       target = connection.target,
       waypoints = connection.waypoints,
       type;
30598
   if (!insert && bendpointIndex === 0) {
     type = RECONNECT_START$1;
   } else
   if (!insert && bendpointIndex === waypoints.length - 1) {
     type = RECONNECT_END$1;
   } else {
     type = UPDATE_WAYPOINTS$1;
   }
30607
   var command = type === UPDATE_WAYPOINTS$1 ? 'connection.updateWaypoints' : 'connection.reconnect';
30609
   var allowed = rules.allowed(command, {
     connection: connection,
     source: source,
     target: target
   });
30615
   if (allowed === false) {
     allowed = rules.allowed(command, {
       connection: connection,
       source: target,
       target: source
     });
   }
30623
   if (allowed === false) {
     return;
   }
30627
   dragging.init(event, 'bendpoint.move', {
     data: {
       connection: connection,
       connectionGfx: gfx,
       context: {
         allowed: allowed,
         bendpointIndex: bendpointIndex,
         connection: connection,
         source: source,
         target: target,
         insert: insert,
         type: type
       }
     }
   });
 };
30644
 eventBus.on('bendpoint.move.hover', function(event) {
   var context = event.context,
       connection = context.connection,
       source = connection.source,
       target = connection.target,
       hover = event.hover,
       type = context.type;
30652
   // cache hover state
   context.hover = hover;
30655
   var allowed;
30657
   if (!hover) {
     return;
   }
30661
   var command = type === UPDATE_WAYPOINTS$1 ? 'connection.updateWaypoints' : 'connection.reconnect';
30663
   allowed = context.allowed = rules.allowed(command, {
     connection: connection,
     source: type === RECONNECT_START$1 ? hover : source,
     target: type === RECONNECT_END$1 ? hover : target
   });
30669
   if (allowed) {
     context.source = type === RECONNECT_START$1 ? hover : source;
     context.target = type === RECONNECT_END$1 ? hover : target;
30673
     return;
   }
30676
   if (allowed === false) {
     allowed = context.allowed = rules.allowed(command, {
       connection: connection,
       source: type === RECONNECT_END$1 ? hover : target,
       target: type === RECONNECT_START$1 ? hover : source
     });
   }
30684
   if (allowed) {
     context.source = type === RECONNECT_END$1 ? hover : target;
     context.target = type === RECONNECT_START$1 ? hover : source;
   }
 });
30690
 eventBus.on([ 'bendpoint.move.out', 'bendpoint.move.cleanup' ], function(event) {
   var context = event.context,
       type = context.type;
30694
   context.hover = null;
   context.source = null;
   context.target = null;
30698
   if (type !== UPDATE_WAYPOINTS$1) {
     context.allowed = false;
   }
 });
30703
 eventBus.on('bendpoint.move.end', function(event) {
   var context = event.context,
       allowed = context.allowed,
       bendpointIndex = context.bendpointIndex,
       connection = context.connection,
       insert = context.insert,
       newWaypoints = connection.waypoints.slice(),
       source = context.source,
       target = context.target,
       type = context.type,
       hints = context.hints || {};
30715
   // ensure integer values (important if zoom level was > 1 during move)
   var docking = {
     x: round$8(event.x),
     y: round$8(event.y)
   };
30721
   if (!allowed) {
     return false;
   }
30725
   if (type === UPDATE_WAYPOINTS$1) {
     if (insert) {
30728
       // insert new bendpoint
       newWaypoints.splice(bendpointIndex, 0, docking);
     } else {
30732
       // swap previous waypoint with moved one
       newWaypoints[bendpointIndex] = docking;
     }
30736
     // pass hints about actual moved bendpoint
     // useful for connection/label layout
     hints.bendpointMove = {
       insert: insert,
       bendpointIndex: bendpointIndex
     };
30743
     newWaypoints = this.cropWaypoints(connection, newWaypoints);
30745
     modeling.updateWaypoints(connection, filterRedundantWaypoints(newWaypoints), hints);
   } else {
     if (type === RECONNECT_START$1) {
       hints.docking = 'source';
30750
       if (isReverse$2(context)) {
         hints.docking = 'target';
30753
         hints.newWaypoints = newWaypoints.reverse();
       }
     } else if (type === RECONNECT_END$1) {
       hints.docking = 'target';
30758
       if (isReverse$2(context)) {
         hints.docking = 'source';
30761
         hints.newWaypoints = newWaypoints.reverse();
       }
     }
30765
     modeling.reconnect(connection, source, target, docking, hints);
   }
 }, this);
}
30770
BendpointMove.$inject = [
 'injector',
 'eventBus',
 'canvas',
 'dragging',
 'rules',
 'modeling'
];
30779
BendpointMove.prototype.cropWaypoints = function(connection, newWaypoints) {
 var connectionDocking = this._injector.get('connectionDocking', false);
30782
 if (!connectionDocking) {
   return newWaypoints;
 }
30786
 var waypoints = connection.waypoints;
30788
 connection.waypoints = newWaypoints;
30790
 connection.waypoints = connectionDocking.getCroppedWaypoints(connection);
30792
 newWaypoints = connection.waypoints;
30794
 connection.waypoints = waypoints;
30796
 return newWaypoints;
};
30799
30800
// helpers //////////
30802
function isReverse$2(context) {
 var hover = context.hover,
     source = context.source,
     target = context.target,
     type = context.type;
30808
 if (type === RECONNECT_START$1) {
   return hover && target && hover === target && source !== target;
 }
30812
 if (type === RECONNECT_END$1) {
   return hover && source && hover === source && source !== target;
 }
}
30817
var RECONNECT_START = 'reconnectStart',
   RECONNECT_END = 'reconnectEnd',
   UPDATE_WAYPOINTS = 'updateWaypoints';
30821
var MARKER_OK$4 = 'connect-ok',
   MARKER_NOT_OK$4 = 'connect-not-ok',
   MARKER_CONNECT_HOVER$1 = 'connect-hover',
   MARKER_CONNECT_UPDATING$1 = 'djs-updating',
   MARKER_ELEMENT_HIDDEN = 'djs-element-hidden';
30827
var HIGH_PRIORITY$j = 1100;
30829
/**
* Preview connection while moving bendpoints.
*/
function BendpointMovePreview(bendpointMove, injector, eventBus, canvas) {
 this._injector = injector;
30835
 var connectionPreview = injector.get('connectionPreview', false);
30837
 eventBus.on('bendpoint.move.start', function(event) {
   var context = event.context,
       bendpointIndex = context.bendpointIndex,
       connection = context.connection,
       insert = context.insert,
       waypoints = connection.waypoints,
       newWaypoints = waypoints.slice();
30845
   context.waypoints = waypoints;
30847
   if (insert) {
30849
     // insert placeholder for new bendpoint
     newWaypoints.splice(bendpointIndex, 0, { x: event.x, y: event.y });
   }
30853
   connection.waypoints = newWaypoints;
30855
   // add dragger gfx
   var draggerGfx = context.draggerGfx = addBendpoint(canvas.getLayer('overlays'));
30858
   classes$1(draggerGfx).add('djs-dragging');
30860
   canvas.addMarker(connection, MARKER_ELEMENT_HIDDEN);
   canvas.addMarker(connection, MARKER_CONNECT_UPDATING$1);
 });
30864
 eventBus.on('bendpoint.move.hover', function(event) {
   var context = event.context,
       allowed = context.allowed,
       hover = context.hover,
       type = context.type;
30870
   if (hover) {
     canvas.addMarker(hover, MARKER_CONNECT_HOVER$1);
30873
     if (type === UPDATE_WAYPOINTS) {
       return;
     }
30877
     if (allowed) {
       canvas.removeMarker(hover, MARKER_NOT_OK$4);
       canvas.addMarker(hover, MARKER_OK$4);
     } else if (allowed === false) {
       canvas.removeMarker(hover, MARKER_OK$4);
       canvas.addMarker(hover, MARKER_NOT_OK$4);
     }
   }
 });
30887
 eventBus.on([
   'bendpoint.move.out',
   'bendpoint.move.cleanup'
 ], HIGH_PRIORITY$j, function(event) {
   var context = event.context,
       hover = context.hover,
       target = context.target;
30895
   if (hover) {
     canvas.removeMarker(hover, MARKER_CONNECT_HOVER$1);
     canvas.removeMarker(hover, target ? MARKER_OK$4 : MARKER_NOT_OK$4);
   }
 });
30901
 eventBus.on('bendpoint.move.move', function(event) {
   var context = event.context,
       allowed = context.allowed,
       bendpointIndex = context.bendpointIndex,
       draggerGfx = context.draggerGfx,
       hover = context.hover,
       type = context.type,
       connection = context.connection,
       source = connection.source,
       target = connection.target,
       newWaypoints = connection.waypoints.slice(),
       bendpoint = { x: event.x, y: event.y },
       hints = context.hints || {},
       drawPreviewHints = {};
30916
   if (connectionPreview) {
     if (hints.connectionStart) {
       drawPreviewHints.connectionStart = hints.connectionStart;
     }
30921
     if (hints.connectionEnd) {
       drawPreviewHints.connectionEnd = hints.connectionEnd;
     }
30925
30926
     if (type === RECONNECT_START) {
       if (isReverse$2(context)) {
         drawPreviewHints.connectionEnd = drawPreviewHints.connectionEnd || bendpoint;
30930
         drawPreviewHints.source = target;
         drawPreviewHints.target = hover || source;
30933
         newWaypoints = newWaypoints.reverse();
       } else {
         drawPreviewHints.connectionStart = drawPreviewHints.connectionStart || bendpoint;
30937
         drawPreviewHints.source = hover || source;
         drawPreviewHints.target = target;
       }
     } else if (type === RECONNECT_END) {
       if (isReverse$2(context)) {
         drawPreviewHints.connectionStart = drawPreviewHints.connectionStart || bendpoint;
30944
         drawPreviewHints.source = hover || target;
         drawPreviewHints.target = source;
30947
         newWaypoints = newWaypoints.reverse();
       } else {
         drawPreviewHints.connectionEnd = drawPreviewHints.connectionEnd || bendpoint;
30951
         drawPreviewHints.source = source;
         drawPreviewHints.target = hover || target;
       }
30955
     } else {
       drawPreviewHints.noCropping = true;
       drawPreviewHints.noLayout = true;
       newWaypoints[ bendpointIndex ] = bendpoint;
     }
30961
     if (type === UPDATE_WAYPOINTS) {
       newWaypoints = bendpointMove.cropWaypoints(connection, newWaypoints);
     }
30965
     drawPreviewHints.waypoints = newWaypoints;
30967
     connectionPreview.drawPreview(context, allowed, drawPreviewHints);
   }
30970
   translate$2(draggerGfx, event.x, event.y);
 }, this);
30973
 eventBus.on([
   'bendpoint.move.end',
   'bendpoint.move.cancel'
 ], HIGH_PRIORITY$j, function(event) {
   var context = event.context,
       connection = context.connection,
       draggerGfx = context.draggerGfx,
       hover = context.hover,
       target = context.target,
       waypoints = context.waypoints;
30984
   connection.waypoints = waypoints;
30986
   // remove dragger gfx
   remove$2(draggerGfx);
30989
   canvas.removeMarker(connection, MARKER_CONNECT_UPDATING$1);
   canvas.removeMarker(connection, MARKER_ELEMENT_HIDDEN);
30992
   if (hover) {
     canvas.removeMarker(hover, MARKER_OK$4);
     canvas.removeMarker(hover, target ? MARKER_OK$4 : MARKER_NOT_OK$4);
   }
30997
   if (connectionPreview) {
     connectionPreview.cleanUp(context);
   }
 });
}
31003
BendpointMovePreview.$inject = [
 'bendpointMove',
 'injector',
 'eventBus',
 'canvas'
];
31010
var MARKER_CONNECT_HOVER = 'connect-hover',
   MARKER_CONNECT_UPDATING = 'djs-updating';
31013
31014
function axisAdd(point, axis, delta) {
 return axisSet(point, axis, point[axis] + delta);
}
31018
function axisSet(point, axis, value) {
 return {
   x: (axis === 'x' ? value : point.x),
   y: (axis === 'y' ? value : point.y)
 };
}
31025
function axisFenced(position, segmentStart, segmentEnd, axis) {
31027
 var maxValue = Math.max(segmentStart[axis], segmentEnd[axis]),
     minValue = Math.min(segmentStart[axis], segmentEnd[axis]);
31030
 var padding = 20;
31032
 var fencedValue = Math.min(Math.max(minValue + padding, position[axis]), maxValue - padding);
31034
 return axisSet(segmentStart, axis, fencedValue);
}
31037
function flipAxis(axis) {
 return axis === 'x' ? 'y' : 'x';
}
31041
/**
* Get the docking point on the given element.
*
* Compute a reasonable docking, if non exists.
*
* @param  {Point} point
* @param  {djs.model.Shape} referenceElement
* @param  {string} moveAxis (x|y)
*
* @return {Point}
*/
function getDocking$2(point, referenceElement, moveAxis) {
31054
 var referenceMid,
     inverseAxis;
31057
 if (point.original) {
   return point.original;
 } else {
   referenceMid = getMid(referenceElement);
   inverseAxis = flipAxis(moveAxis);
31063
   return axisSet(point, inverseAxis, referenceMid[inverseAxis]);
 }
}
31067
/**
* A component that implements moving of bendpoints
*/
function ConnectionSegmentMove(
   injector, eventBus, canvas,
   dragging, graphicsFactory, modeling) {
31074
 // optional connection docking integration
 var connectionDocking = injector.get('connectionDocking', false);
31077
31078
 // API
31080
 this.start = function(event, connection, idx) {
31082
   var context,
       gfx = canvas.getGraphics(connection),
       segmentStartIndex = idx - 1,
       segmentEndIndex = idx,
       waypoints = connection.waypoints,
       segmentStart = waypoints[segmentStartIndex],
       segmentEnd = waypoints[segmentEndIndex],
       intersection = getConnectionIntersection(canvas, waypoints, event),
       direction, axis, dragPosition;
31092
   direction = pointsAligned(segmentStart, segmentEnd);
31094
   // do not move diagonal connection
   if (!direction) {
     return;
   }
31099
   // the axis where we are going to move things
   axis = direction === 'v' ? 'x' : 'y';
31102
   if (segmentStartIndex === 0) {
     segmentStart = getDocking$2(segmentStart, connection.source, axis);
   }
31106
   if (segmentEndIndex === waypoints.length - 1) {
     segmentEnd = getDocking$2(segmentEnd, connection.target, axis);
   }
31110
   if (intersection) {
     dragPosition = intersection.point;
   } else {
31114
     // set to segment center as default
     dragPosition = {
       x: (segmentStart.x + segmentEnd.x) / 2,
       y: (segmentStart.y + segmentEnd.y) / 2
     };
   }
31121
   context = {
     connection: connection,
     segmentStartIndex: segmentStartIndex,
     segmentEndIndex: segmentEndIndex,
     segmentStart: segmentStart,
     segmentEnd: segmentEnd,
     axis: axis,
     dragPosition: dragPosition
   };
31131
   dragging.init(event, dragPosition, 'connectionSegment.move', {
     cursor: axis === 'x' ? 'resize-ew' : 'resize-ns',
     data: {
       connection: connection,
       connectionGfx: gfx,
       context: context
     }
   });
 };
31141
 /**
  * Crop connection if connection cropping is provided.
  *
  * @param {Connection} connection
  * @param {Array<Point>} newWaypoints
  *
  * @return {Array<Point>} cropped connection waypoints
  */
 function cropConnection(connection, newWaypoints) {
31151
   // crop connection, if docking service is provided only
   if (!connectionDocking) {
     return newWaypoints;
   }
31156
   var oldWaypoints = connection.waypoints,
       croppedWaypoints;
31159
   // temporary set new waypoints
   connection.waypoints = newWaypoints;
31162
   croppedWaypoints = connectionDocking.getCroppedWaypoints(connection);
31164
   // restore old waypoints
   connection.waypoints = oldWaypoints;
31167
   return croppedWaypoints;
 }
31170
 // DRAGGING IMPLEMENTATION
31172
 function redrawConnection(data) {
   graphicsFactory.update('connection', data.connection, data.connectionGfx);
 }
31176
 function updateDragger(context, segmentOffset, event) {
31178
   var newWaypoints = context.newWaypoints,
       segmentStartIndex = context.segmentStartIndex + segmentOffset,
       segmentStart = newWaypoints[segmentStartIndex],
       segmentEndIndex = context.segmentEndIndex + segmentOffset,
       segmentEnd = newWaypoints[segmentEndIndex],
       axis = flipAxis(context.axis);
31185
   // make sure the dragger does not move
   // outside the connection
   var draggerPosition = axisFenced(event, segmentStart, segmentEnd, axis);
31189
   // update dragger
   translate$2(context.draggerGfx, draggerPosition.x, draggerPosition.y);
 }
31193
 /**
  * Filter waypoints for redundant ones (i.e. on the same axis).
  * Returns the filtered waypoints and the offset related to the segment move.
  *
  * @param {Array<Point>} waypoints
  * @param {Integer} segmentStartIndex of moved segment start
  *
  * @return {Object} { filteredWaypoints, segmentOffset }
  */
 function filterRedundantWaypoints(waypoints, segmentStartIndex) {
31204
   var segmentOffset = 0;
31206
   var filteredWaypoints = waypoints.filter(function(r, idx) {
     if (pointsOnLine(waypoints[idx - 1], waypoints[idx + 1], r)) {
31209
       // remove point and increment offset
       segmentOffset = idx <= segmentStartIndex ? segmentOffset - 1 : segmentOffset;
       return false;
     }
31214
     // dont remove point
     return true;
   });
31218
   return {
     waypoints: filteredWaypoints,
     segmentOffset: segmentOffset
   };
 }
31224
 eventBus.on('connectionSegment.move.start', function(event) {
31226
   var context = event.context,
       connection = event.connection,
       layer = canvas.getLayer('overlays');
31230
   context.originalWaypoints = connection.waypoints.slice();
31232
   // add dragger gfx
   context.draggerGfx = addSegmentDragger(layer, context.segmentStart, context.segmentEnd);
   classes$1(context.draggerGfx).add('djs-dragging');
31236
   canvas.addMarker(connection, MARKER_CONNECT_UPDATING);
 });
31239
 eventBus.on('connectionSegment.move.move', function(event) {
31241
   var context = event.context,
       connection = context.connection,
       segmentStartIndex = context.segmentStartIndex,
       segmentEndIndex = context.segmentEndIndex,
       segmentStart = context.segmentStart,
       segmentEnd = context.segmentEnd,
       axis = context.axis;
31249
   var newWaypoints = context.originalWaypoints.slice(),
       newSegmentStart = axisAdd(segmentStart, axis, event['d' + axis]),
       newSegmentEnd = axisAdd(segmentEnd, axis, event['d' + axis]);
31253
   // original waypoint count and added / removed
   // from start waypoint delta. We use the later
   // to retrieve the updated segmentStartIndex / segmentEndIndex
   var waypointCount = newWaypoints.length,
       segmentOffset = 0;
31259
   // move segment start / end by axis delta
   newWaypoints[segmentStartIndex] = newSegmentStart;
   newWaypoints[segmentEndIndex] = newSegmentEnd;
31263
   var sourceToSegmentOrientation,
       targetToSegmentOrientation;
31266
   // handle first segment
   if (segmentStartIndex < 2) {
     sourceToSegmentOrientation = getOrientation(connection.source, newSegmentStart);
31270
     // first bendpoint, remove first segment if intersecting
     if (segmentStartIndex === 1) {
31273
       if (sourceToSegmentOrientation === 'intersect') {
         newWaypoints.shift();
         newWaypoints[0] = newSegmentStart;
         segmentOffset--;
       }
     }
31280
     // docking point, add segment if not intersecting anymore
     else {
       if (sourceToSegmentOrientation !== 'intersect') {
         newWaypoints.unshift(segmentStart);
         segmentOffset++;
       }
     }
   }
31289
   // handle last segment
   if (segmentEndIndex > waypointCount - 3) {
     targetToSegmentOrientation = getOrientation(connection.target, newSegmentEnd);
31293
     // last bendpoint, remove last segment if intersecting
     if (segmentEndIndex === waypointCount - 2) {
31296
       if (targetToSegmentOrientation === 'intersect') {
         newWaypoints.pop();
         newWaypoints[newWaypoints.length - 1] = newSegmentEnd;
       }
     }
31302
     // last bendpoint, remove last segment if intersecting
     else {
       if (targetToSegmentOrientation !== 'intersect') {
         newWaypoints.push(segmentEnd);
       }
     }
   }
31310
   // update connection waypoints
   context.newWaypoints = connection.waypoints = cropConnection(connection, newWaypoints);
31313
   // update dragger position
   updateDragger(context, segmentOffset, event);
31316
   // save segmentOffset in context
   context.newSegmentStartIndex = segmentStartIndex + segmentOffset;
31319
   // redraw connection
   redrawConnection(event);
 });
31323
 eventBus.on('connectionSegment.move.hover', function(event) {
31325
   event.context.hover = event.hover;
   canvas.addMarker(event.hover, MARKER_CONNECT_HOVER);
 });
31329
 eventBus.on([
   'connectionSegment.move.out',
   'connectionSegment.move.cleanup'
 ], function(event) {
31334
   // remove connect marker
   // if it was added
   var hover = event.context.hover;
31338
   if (hover) {
     canvas.removeMarker(hover, MARKER_CONNECT_HOVER);
   }
 });
31343
 eventBus.on('connectionSegment.move.cleanup', function(event) {
31345
   var context = event.context,
       connection = context.connection;
31348
   // remove dragger gfx
   if (context.draggerGfx) {
     remove$2(context.draggerGfx);
   }
31353
   canvas.removeMarker(connection, MARKER_CONNECT_UPDATING);
 });
31356
 eventBus.on([
   'connectionSegment.move.cancel',
   'connectionSegment.move.end'
 ], function(event) {
   var context = event.context,
       connection = context.connection;
31363
   connection.waypoints = context.originalWaypoints;
31365
   redrawConnection(event);
 });
31368
 eventBus.on('connectionSegment.move.end', function(event) {
31370
   var context = event.context,
       connection = context.connection,
       newWaypoints = context.newWaypoints,
       newSegmentStartIndex = context.newSegmentStartIndex;
31375
   // ensure we have actual pixel values bendpoint
   // coordinates (important when zoom level was > 1 during move)
   newWaypoints = newWaypoints.map(function(p) {
     return {
       original: p.original,
       x: Math.round(p.x),
       y: Math.round(p.y)
     };
   });
31385
   // apply filter redunant waypoints
   var filtered = filterRedundantWaypoints(newWaypoints, newSegmentStartIndex);
31388
   // get filtered waypoints
   var filteredWaypoints = filtered.waypoints,
       croppedWaypoints = cropConnection(connection, filteredWaypoints),
       segmentOffset = filtered.segmentOffset;
31393
   var hints = {
     segmentMove: {
       segmentStartIndex: context.segmentStartIndex,
       newSegmentStartIndex: newSegmentStartIndex + segmentOffset
     }
   };
31400
   modeling.updateWaypoints(connection, croppedWaypoints, hints);
 });
}
31404
ConnectionSegmentMove.$inject = [
 'injector',
 'eventBus',
 'canvas',
 'dragging',
 'graphicsFactory',
 'modeling'
];
31413
var abs$6 = Math.abs,
   round$7 = Math.round;
31416
31417
/**
* Snap value to a collection of reference values.
*
* @param  {number} value
* @param  {Array<number>} values
* @param  {number} [tolerance=10]
*
* @return {number} the value we snapped to or null, if none snapped
*/
function snapTo(value, values, tolerance) {
 tolerance = tolerance === undefined ? 10 : tolerance;
31429
 var idx, snapValue;
31431
 for (idx = 0; idx < values.length; idx++) {
   snapValue = values[idx];
31434
   if (abs$6(snapValue - value) <= tolerance) {
     return snapValue;
   }
 }
}
31440
31441
function topLeft(bounds) {
 return {
   x: bounds.x,
   y: bounds.y
 };
}
31448
function bottomRight(bounds) {
 return {
   x: bounds.x + bounds.width,
   y: bounds.y + bounds.height
 };
}
31455
function mid$2(bounds, defaultValue) {
31457
 if (!bounds || isNaN(bounds.x) || isNaN(bounds.y)) {
   return defaultValue;
 }
31461
 return {
   x: round$7(bounds.x + bounds.width / 2),
   y: round$7(bounds.y + bounds.height / 2)
 };
}
31467
31468
/**
* Retrieve the snap state of the given event.
*
* @param  {Event} event
* @param  {string} axis
*
* @return {boolean} the snapped state
*
*/
function isSnapped(event, axis) {
 var snapped = event.snapped;
31480
 if (!snapped) {
   return false;
 }
31484
 if (typeof axis === 'string') {
   return snapped[axis];
 }
31488
 return snapped.x && snapped.y;
}
31491
31492
/**
* Set the given event as snapped.
*
* This method may change the x and/or y position of the shape
* from the given event!
*
* @param {Event} event
* @param {string} axis
* @param {number|boolean} value
*
* @return {number} old value
*/
function setSnapped(event, axis, value) {
 if (typeof axis !== 'string') {
   throw new Error('axis must be in [x, y]');
 }
31509
 if (typeof value !== 'number' && value !== false) {
   throw new Error('value must be Number or false');
 }
31513
 var delta,
     previousValue = event[axis];
31516
 var snapped = event.snapped = (event.snapped || {});
31518
31519
 if (value === false) {
   snapped[axis] = false;
 } else {
   snapped[axis] = true;
31524
   delta = value - previousValue;
31526
   event[axis] += delta;
   event['d' + axis] += delta;
 }
31530
 return previousValue;
}
31533
/**
* Get children of a shape.
*
* @param {djs.model.Shape} parent
*
* @returns {Array<djs.model.Shape|djs.model.Connection>}
*/
function getChildren(parent) {
 return parent.children || [];
}
31544
var abs$5 = Math.abs,
   round$6 = Math.round;
31547
var TOLERANCE = 10;
31549
31550
function BendpointSnapping(eventBus) {
31552
 function snapTo(values, value) {
31554
   if (isArray$4(values)) {
     var i = values.length;
31557
     while (i--) if (abs$5(values[i] - value) <= TOLERANCE) {
       return values[i];
     }
   } else {
     values = +values;
     var rem = value % values;
31564
     if (rem < TOLERANCE) {
       return value - rem;
     }
31568
     if (rem > values - TOLERANCE) {
       return value - rem + values;
     }
   }
31573
   return value;
 }
31576
 function mid(element) {
   if (element.width) {
     return {
       x: round$6(element.width / 2 + element.x),
       y: round$6(element.height / 2 + element.y)
     };
   }
 }
31585
 // connection segment snapping //////////////////////
31587
 function getConnectionSegmentSnaps(context) {
31589
   var snapPoints = context.snapPoints,
       connection = context.connection,
       waypoints = connection.waypoints,
       segmentStart = context.segmentStart,
       segmentStartIndex = context.segmentStartIndex,
       segmentEnd = context.segmentEnd,
       segmentEndIndex = context.segmentEndIndex,
       axis = context.axis;
31598
   if (snapPoints) {
     return snapPoints;
   }
31602
   var referenceWaypoints = [
     waypoints[segmentStartIndex - 1],
     segmentStart,
     segmentEnd,
     waypoints[segmentEndIndex + 1]
   ];
31609
   if (segmentStartIndex < 2) {
     referenceWaypoints.unshift(mid(connection.source));
   }
31613
   if (segmentEndIndex > waypoints.length - 3) {
     referenceWaypoints.unshift(mid(connection.target));
   }
31617
   context.snapPoints = snapPoints = { horizontal: [] , vertical: [] };
31619
   forEach$2(referenceWaypoints, function(p) {
31621
     // we snap on existing bendpoints only,
     // not placeholders that are inserted during add
     if (p) {
       p = p.original || p;
31626
       if (axis === 'y') {
         snapPoints.horizontal.push(p.y);
       }
31630
       if (axis === 'x') {
         snapPoints.vertical.push(p.x);
       }
     }
   });
31636
   return snapPoints;
 }
31639
 eventBus.on('connectionSegment.move.move', 1500, function(event) {
   var context = event.context,
       snapPoints = getConnectionSegmentSnaps(context),
       x = event.x,
       y = event.y,
       sx, sy;
31646
   if (!snapPoints) {
     return;
   }
31650
   // snap
   sx = snapTo(snapPoints.vertical, x);
   sy = snapTo(snapPoints.horizontal, y);
31654
31655
   // correction x/y
   var cx = (x - sx),
       cy = (y - sy);
31659
   // update delta
   assign(event, {
     dx: event.dx - cx,
     dy: event.dy - cy,
     x: sx,
     y: sy
   });
31667
   // only set snapped if actually snapped
   if (cx || snapPoints.vertical.indexOf(x) !== -1) {
     setSnapped(event, 'x', sx);
   }
31672
   if (cy || snapPoints.horizontal.indexOf(y) !== -1) {
     setSnapped(event, 'y', sy);
   }
 });
31677
31678
 // bendpoint snapping //////////////////////
31680
 function getBendpointSnaps(context) {
31682
   var snapPoints = context.snapPoints,
       waypoints = context.connection.waypoints,
       bendpointIndex = context.bendpointIndex;
31686
   if (snapPoints) {
     return snapPoints;
   }
31690
   var referenceWaypoints = [ waypoints[bendpointIndex - 1], waypoints[bendpointIndex + 1] ];
31692
   context.snapPoints = snapPoints = { horizontal: [] , vertical: [] };
31694
   forEach$2(referenceWaypoints, function(p) {
31696
     // we snap on existing bendpoints only,
     // not placeholders that are inserted during add
     if (p) {
       p = p.original || p;
31701
       snapPoints.horizontal.push(p.y);
       snapPoints.vertical.push(p.x);
     }
   });
31706
   return snapPoints;
 }
31709
31710
 eventBus.on([ 'bendpoint.move.move', 'bendpoint.move.end' ], 1500, function(event) {
31712
   var context = event.context,
       snapPoints = getBendpointSnaps(context),
       hover = context.hover,
       hoverMid = hover && mid(hover),
       x = event.x,
       y = event.y,
       sx, sy;
31720
   if (!snapPoints) {
     return;
   }
31724
   // snap to hover mid
   sx = snapTo(hoverMid ? snapPoints.vertical.concat([ hoverMid.x ]) : snapPoints.vertical, x);
   sy = snapTo(hoverMid ? snapPoints.horizontal.concat([ hoverMid.y ]) : snapPoints.horizontal, y);
31728
   // correction x/y
   var cx = (x - sx),
       cy = (y - sy);
31732
   // update delta
   assign(event, {
     dx: event.dx - cx,
     dy: event.dy - cy,
     x: event.x - cx,
     y: event.y - cy
   });
31740
   // only set snapped if actually snapped
   if (cx || snapPoints.vertical.indexOf(x) !== -1) {
     setSnapped(event, 'x', sx);
   }
31745
   if (cy || snapPoints.horizontal.indexOf(y) !== -1) {
     setSnapped(event, 'y', sy);
   }
 });
}
31751
31752
BendpointSnapping.$inject = [ 'eventBus' ];
31754
var BendpointsModule = {
 __depends__: [
   DraggingModule,
   RulesModule$1
 ],
 __init__: [ 'bendpoints', 'bendpointSnapping', 'bendpointMovePreview' ],
 bendpoints: [ 'type', Bendpoints ],
 bendpointMove: [ 'type', BendpointMove ],
 bendpointMovePreview: [ 'type', BendpointMovePreview ],
 connectionSegmentMove: [ 'type', ConnectionSegmentMove ],
 bendpointSnapping: [ 'type', BendpointSnapping ]
};
31767
function Connect(eventBus, dragging, modeling, rules) {
31769
 // rules
31771
 function canConnect(source, target) {
   return rules.allowed('connection.create', {
     source: source,
     target: target
   });
 }
31778
 function canConnectReverse(source, target) {
   return canConnect(target, source);
 }
31782
31783
 // event handlers
31785
 eventBus.on('connect.hover', function(event) {
   var context = event.context,
       start = context.start,
       hover = event.hover,
       canExecute;
31791
   // cache hover state
   context.hover = hover;
31794
   canExecute = context.canExecute = canConnect(start, hover);
31796
   // ignore hover
   if (isNil(canExecute)) {
     return;
   }
31801
   if (canExecute !== false) {
     context.source = start;
     context.target = hover;
31805
     return;
   }
31808
   canExecute = context.canExecute = canConnectReverse(start, hover);
31810
   // ignore hover
   if (isNil(canExecute)) {
     return;
   }
31815
   if (canExecute !== false) {
     context.source = hover;
     context.target = start;
   }
 });
31821
 eventBus.on([ 'connect.out', 'connect.cleanup' ], function(event) {
   var context = event.context;
31824
   context.hover = null;
   context.source = null;
   context.target = null;
31828
   context.canExecute = false;
 });
31831
 eventBus.on('connect.end', function(event) {
   var context = event.context,
       canExecute = context.canExecute,
       connectionStart = context.connectionStart,
       connectionEnd = {
         x: event.x,
         y: event.y
       },
       source = context.source,
       target = context.target;
31842
   if (!canExecute) {
     return false;
   }
31846
   var attrs = null,
       hints = {
         connectionStart: isReverse$1(context) ? connectionEnd : connectionStart,
         connectionEnd: isReverse$1(context) ? connectionStart : connectionEnd
       };
31852
   if (isObject(canExecute)) {
     attrs = canExecute;
   }
31856
   modeling.connect(source, target, attrs, hints);
 });
31859
31860
 // API
31862
 /**
  * Start connect operation.
  *
  * @param {DOMEvent} event
  * @param {djs.model.Base} start
  * @param {Point} [connectionStart]
  * @param {boolean} [autoActivate=false]
  */
 this.start = function(event, start, connectionStart, autoActivate) {
   if (!isObject(connectionStart)) {
     autoActivate = connectionStart;
     connectionStart = getMid(start);
   }
31876
   dragging.init(event, 'connect', {
     autoActivate: autoActivate,
     data: {
       shape: start,
       context: {
         start: start,
         connectionStart: connectionStart
       }
     }
   });
 };
}
31889
Connect.$inject = [
 'eventBus',
 'dragging',
 'modeling',
 'rules'
];
31896
31897
// helpers //////////
31899
function isReverse$1(context) {
 var hover = context.hover,
     source = context.source,
     target = context.target;
31904
 return hover && source && hover === source && source !== target;
}
31907
var HIGH_PRIORITY$i = 1100,
   LOW_PRIORITY$i = 900;
31910
var MARKER_OK$3 = 'connect-ok',
   MARKER_NOT_OK$3 = 'connect-not-ok';
31913
/**
* Shows connection preview during connect.
*
* @param {didi.Injector} injector
* @param {EventBus} eventBus
* @param {Canvas} canvas
*/
function ConnectPreview(injector, eventBus, canvas) {
 var connectionPreview = injector.get('connectionPreview', false);
31923
 connectionPreview && eventBus.on('connect.move', function(event) {
   var context = event.context,
       canConnect = context.canExecute,
       hover = context.hover,
       source = context.source,
       start = context.start,
       startPosition = context.startPosition,
       target = context.target,
       connectionStart = context.connectionStart || startPosition,
       connectionEnd = context.connectionEnd || {
         x: event.x,
         y: event.y
       },
       previewStart = connectionStart,
       previewEnd = connectionEnd;
31939
   if (isReverse$1(context)) {
     previewStart = connectionEnd;
     previewEnd = connectionStart;
   }
31944
   connectionPreview.drawPreview(context, canConnect, {
     source: source || start,
     target: target || hover,
     connectionStart: previewStart,
     connectionEnd: previewEnd
   });
 });
31952
 eventBus.on('connect.hover', LOW_PRIORITY$i, function(event) {
   var context = event.context,
       hover = event.hover,
       canExecute = context.canExecute;
31957
   // ignore hover
   if (canExecute === null) {
     return;
   }
31962
   canvas.addMarker(hover, canExecute ? MARKER_OK$3 : MARKER_NOT_OK$3);
 });
31965
 eventBus.on([
   'connect.out',
   'connect.cleanup'
 ], HIGH_PRIORITY$i, function(event) {
   var hover = event.hover;
31971
   if (hover) {
     canvas.removeMarker(hover, MARKER_OK$3);
     canvas.removeMarker(hover, MARKER_NOT_OK$3);
   }
 });
31977
 connectionPreview && eventBus.on('connect.cleanup', function(event) {
   connectionPreview.cleanUp(event.context);
 });
}
31982
ConnectPreview.$inject = [
 'injector',
 'eventBus',
 'canvas'
];
31988
var ConnectModule = {
 __depends__: [
   SelectionModule,
   RulesModule$1,
   DraggingModule
 ],
 __init__: [
   'connectPreview'
 ],
 connect: [ 'type', Connect ],
 connectPreview: [ 'type', ConnectPreview ]
};
32001
var MARKER_CONNECTION_PREVIEW = 'djs-connection-preview';
32003
/**
* Draws connection preview. Optionally, this can use layouter and connection docking to draw
* better looking previews.
*
* @param {didi.Injector} injector
* @param {Canvas} canvas
* @param {GraphicsFactory} graphicsFactory
* @param {ElementFactory} elementFactory
*/
function ConnectionPreview(
   injector,
   canvas,
   graphicsFactory,
   elementFactory
) {
 this._canvas = canvas;
 this._graphicsFactory = graphicsFactory;
 this._elementFactory = elementFactory;
32022
 // optional components
 this._connectionDocking = injector.get('connectionDocking', false);
 this._layouter = injector.get('layouter', false);
}
32027
ConnectionPreview.$inject = [
 'injector',
 'canvas',
 'graphicsFactory',
 'elementFactory'
];
32034
/**
* Draw connection preview.
*
* Provide at least one of <source, connectionStart> and <target, connectionEnd> to create a preview.
* In the clean up stage, call `connectionPreview#cleanUp` with the context to remove preview.
*
* @param {Object} context
* @param {Object|boolean} canConnect
* @param {Object} hints
* @param {djs.model.shape} [hints.source] source element
* @param {djs.model.shape} [hints.target] target element
* @param {Point} [hints.connectionStart] connection preview start
* @param {Point} [hints.connectionEnd] connection preview end
* @param {Array<Point>} [hints.waypoints] provided waypoints for preview
* @param {boolean} [hints.noLayout] true if preview should not be laid out
* @param {boolean} [hints.noCropping] true if preview should not be cropped
* @param {boolean} [hints.noNoop] true if simple connection should not be drawn
*/
ConnectionPreview.prototype.drawPreview = function(context, canConnect, hints) {
32054
 hints = hints || {};
32056
 var connectionPreviewGfx = context.connectionPreviewGfx,
     getConnection = context.getConnection,
     source = hints.source,
     target = hints.target,
     waypoints = hints.waypoints,
     connectionStart = hints.connectionStart,
     connectionEnd = hints.connectionEnd,
     noLayout = hints.noLayout,
     noCropping = hints.noCropping,
     noNoop = hints.noNoop,
     connection;
32068
 var self = this;
32070
 if (!connectionPreviewGfx) {
   connectionPreviewGfx = context.connectionPreviewGfx = this.createConnectionPreviewGfx();
 }
32074
 clear$1(connectionPreviewGfx);
32076
 if (!getConnection) {
   getConnection = context.getConnection = cacheReturnValues(function(canConnect, source, target) {
     return self.getConnection(canConnect, source, target);
   });
 }
32082
 if (canConnect) {
   connection = getConnection(canConnect, source, target);
 }
32086
 if (!connection) {
   !noNoop && this.drawNoopPreview(connectionPreviewGfx, hints);
   return;
 }
32091
 connection.waypoints = waypoints || [];
32093
 // optional layout
 if (this._layouter && !noLayout) {
   connection.waypoints = this._layouter.layoutConnection(connection, {
     source: source,
     target: target,
     connectionStart: connectionStart,
     connectionEnd: connectionEnd,
     waypoints: hints.waypoints || connection.waypoints
   });
 }
32104
 // fallback if no waypoints were provided nor created with layouter
 if (!connection.waypoints || !connection.waypoints.length) {
   connection.waypoints = [
     source ? getMid(source) : connectionStart,
     target ? getMid(target) : connectionEnd
   ];
 }
32112
 // optional cropping
 if (this._connectionDocking && (source || target) && !noCropping) {
   connection.waypoints = this._connectionDocking.getCroppedWaypoints(connection, source, target);
 }
32117
 this._graphicsFactory.drawConnection(connectionPreviewGfx, connection);
};
32120
/**
* Draw simple connection between source and target or provided points.
*
* @param {SVGElement} connectionPreviewGfx container for the connection
* @param {Object} hints
* @param {djs.model.shape} [hints.source] source element
* @param {djs.model.shape} [hints.target] target element
* @param {Point} [hints.connectionStart] required if source is not provided
* @param {Point} [hints.connectionEnd] required if target is not provided
*/
ConnectionPreview.prototype.drawNoopPreview = function(connectionPreviewGfx, hints) {
 var source = hints.source,
     target = hints.target,
     start = hints.connectionStart || getMid(source),
     end = hints.connectionEnd || getMid(target);
32136
 var waypoints = this.cropWaypoints(start, end, source, target);
32138
 var connection = this.createNoopConnection(waypoints[0], waypoints[1]);
32140
 append(connectionPreviewGfx, connection);
};
32143
/**
* Return cropped waypoints.
*
* @param {Point} start
* @param {Point} end
* @param {djs.model.shape} source
* @param {djs.model.shape} target
*
* @returns {Array}
*/
ConnectionPreview.prototype.cropWaypoints = function(start, end, source, target) {
 var graphicsFactory = this._graphicsFactory,
     sourcePath = source && graphicsFactory.getShapePath(source),
     targetPath = target && graphicsFactory.getShapePath(target),
     connectionPath = graphicsFactory.getConnectionPath({ waypoints: [ start, end ] });
32159
 start = (source && getElementLineIntersection(sourcePath, connectionPath, true)) || start;
 end = (target && getElementLineIntersection(targetPath, connectionPath, false)) || end;
32162
 return [ start, end ];
};
32165
/**
* Remove connection preview container if it exists.
*
* @param {Object} [context]
* @param {SVGElement} [context.connectionPreviewGfx] preview container
*/
ConnectionPreview.prototype.cleanUp = function(context) {
 if (context && context.connectionPreviewGfx) {
   remove$2(context.connectionPreviewGfx);
 }
};
32177
/**
* Get connection that connects source and target.
*
* @param {Object|boolean} canConnect
*
* @returns {djs.model.connection}
*/
ConnectionPreview.prototype.getConnection = function(canConnect) {
 var attrs = ensureConnectionAttrs(canConnect);
32187
 return this._elementFactory.createConnection(attrs);
};
32190
32191
/**
* Add and return preview graphics.
*
* @returns {SVGElement}
*/
ConnectionPreview.prototype.createConnectionPreviewGfx = function() {
 var gfx = create$1('g');
32199
 attr$1(gfx, {
   pointerEvents: 'none'
 });
32203
 classes$1(gfx).add(MARKER_CONNECTION_PREVIEW);
32205
 append(this._canvas.getActiveLayer(), gfx);
32207
 return gfx;
};
32210
/**
* Create and return simple connection.
*
* @param {Point} start
* @param {Point} end
*
* @returns {SVGElement}
*/
ConnectionPreview.prototype.createNoopConnection = function(start, end) {
 var connection = create$1('polyline');
32221
 attr$1(connection, {
   'stroke': '#333',
   'strokeDasharray': [ 1 ],
   'strokeWidth': 2,
   'pointer-events': 'none'
 });
32228
 attr$1(connection, { 'points': [ start.x, start.y, end.x, end.y ] });
32230
 return connection;
};
32233
// helpers //////////
32235
/**
* Returns function that returns cached return values referenced by stringified first argument.
*
* @param {Function} fn
*
* @return {Function}
*/
function cacheReturnValues(fn) {
 var returnValues = {};
32245
 /**
  * Return cached return value referenced by stringified first argument.
  *
  * @returns {*}
  */
 return function(firstArgument) {
   var key = JSON.stringify(firstArgument);
32253
   var returnValue = returnValues[key];
32255
   if (!returnValue) {
     returnValue = returnValues[key] = fn.apply(null, arguments);
   }
32259
   return returnValue;
 };
}
32263
/**
* Ensure connection attributes is object.
*
* @param {Object|boolean} canConnect
*
* @returns {Object}
*/
function ensureConnectionAttrs(canConnect) {
 if (isObject(canConnect)) {
   return canConnect;
 } else {
   return {};
 }
}
32278
var ConnectionPreviewModule = {
 __init__: [ 'connectionPreview' ],
 connectionPreview: [ 'type', ConnectionPreview ]
};
32283
var min$3 = Math.min,
   max$5 = Math.max;
32286
function preventDefault(e) {
 e.preventDefault();
}
32290
function stopPropagation(e) {
 e.stopPropagation();
}
32294
function isTextNode(node) {
 return node.nodeType === Node.TEXT_NODE;
}
32298
function toArray(nodeList) {
 return [].slice.call(nodeList);
}
32302
/**
* Initializes a container for a content editable div.
*
* Structure:
*
* container
*   parent
*     content
*     resize-handle
*
* @param {object} options
* @param {DOMElement} options.container The DOM element to append the contentContainer to
* @param {Function} options.keyHandler Handler for key events
* @param {Function} options.resizeHandler Handler for resize events
*/
function TextBox(options) {
 this.container = options.container;
32320
 this.parent = domify$1(
   '<div class="djs-direct-editing-parent">' +
     '<div class="djs-direct-editing-content" contenteditable="true"></div>' +
   '</div>'
 );
32326
 this.content = query$1('[contenteditable]', this.parent);
32328
 this.keyHandler = options.keyHandler || function() {};
 this.resizeHandler = options.resizeHandler || function() {};
32331
 this.autoResize = bind(this.autoResize, this);
 this.handlePaste = bind(this.handlePaste, this);
}
32335
32336
/**
* Create a text box with the given position, size, style and text content
*
* @param {Object} bounds
* @param {Number} bounds.x absolute x position
* @param {Number} bounds.y absolute y position
* @param {Number} [bounds.width] fixed width value
* @param {Number} [bounds.height] fixed height value
* @param {Number} [bounds.maxWidth] maximum width value
* @param {Number} [bounds.maxHeight] maximum height value
* @param {Number} [bounds.minWidth] minimum width value
* @param {Number} [bounds.minHeight] minimum height value
* @param {Object} [style]
* @param {String} value text content
*
* @return {DOMElement} The created content DOM element
*/
TextBox.prototype.create = function(bounds, style, value, options) {
 var self = this;
32356
 var parent = this.parent,
     content = this.content,
     container = this.container;
32360
 options = this.options = options || {};
32362
 style = this.style = style || {};
32364
 var parentStyle = pick(style, [
   'width',
   'height',
   'maxWidth',
   'maxHeight',
   'minWidth',
   'minHeight',
   'left',
   'top',
   'backgroundColor',
   'position',
   'overflow',
   'border',
   'wordWrap',
   'textAlign',
   'outline',
   'transform'
 ]);
32383
 assign(parent.style, {
   width: bounds.width + 'px',
   height: bounds.height + 'px',
   maxWidth: bounds.maxWidth + 'px',
   maxHeight: bounds.maxHeight + 'px',
   minWidth: bounds.minWidth + 'px',
   minHeight: bounds.minHeight + 'px',
   left: bounds.x + 'px',
   top: bounds.y + 'px',
   backgroundColor: '#ffffff',
   position: 'absolute',
   overflow: 'visible',
   border: '1px solid #ccc',
   boxSizing: 'border-box',
   wordWrap: 'normal',
   textAlign: 'center',
   outline: 'none'
 }, parentStyle);
32402
 var contentStyle = pick(style, [
   'fontFamily',
   'fontSize',
   'fontWeight',
   'lineHeight',
   'padding',
   'paddingTop',
   'paddingRight',
   'paddingBottom',
   'paddingLeft'
 ]);
32414
 assign(content.style, {
   boxSizing: 'border-box',
   width: '100%',
   outline: 'none',
   wordWrap: 'break-word'
 }, contentStyle);
32421
 if (options.centerVertically) {
   assign(content.style, {
     position: 'absolute',
     top: '50%',
     transform: 'translate(0, -50%)'
   }, contentStyle);
 }
32429
 content.innerText = value;
32431
 componentEvent$1.bind(content, 'keydown', this.keyHandler);
 componentEvent$1.bind(content, 'mousedown', stopPropagation);
 componentEvent$1.bind(content, 'paste', self.handlePaste);
32435
 if (options.autoResize) {
   componentEvent$1.bind(content, 'input', this.autoResize);
 }
32439
 if (options.resizable) {
   this.resizable(style);
 }
32443
 container.appendChild(parent);
32445
 // set selection to end of text
 this.setSelection(content.lastChild, content.lastChild && content.lastChild.length);
32448
 return parent;
};
32451
/**
* Intercept paste events to remove formatting from pasted text.
*/
TextBox.prototype.handlePaste = function(e) {
 var options = this.options,
     style = this.style;
32458
 e.preventDefault();
32460
 var text;
32462
 if (e.clipboardData) {
32464
   // Chrome, Firefox, Safari
   text = e.clipboardData.getData('text/plain');
 } else {
32468
   // Internet Explorer
   text = window.clipboardData.getData('Text');
 }
32472
 this.insertText(text);
32474
 if (options.autoResize) {
   var hasResized = this.autoResize(style);
32477
   if (hasResized) {
     this.resizeHandler(hasResized);
   }
 }
};
32483
TextBox.prototype.insertText = function(text) {
 text = normalizeEndOfLineSequences(text);
32486
 // insertText command not supported by Internet Explorer
 var success = document.execCommand('insertText', false, text);
32489
 if (success) {
   return;
 }
32493
 this._insertTextIE(text);
};
32496
TextBox.prototype._insertTextIE = function(text) {
32498
 // Internet Explorer
 var range = this.getSelection(),
     startContainer = range.startContainer,
     endContainer = range.endContainer,
     startOffset = range.startOffset,
     endOffset = range.endOffset,
     commonAncestorContainer = range.commonAncestorContainer;
32506
 var childNodesArray = toArray(commonAncestorContainer.childNodes);
32508
 var container,
     offset;
32511
 if (isTextNode(commonAncestorContainer)) {
   var containerTextContent = startContainer.textContent;
32514
   startContainer.textContent =
     containerTextContent.substring(0, startOffset)
     + text
     + containerTextContent.substring(endOffset);
32519
   container = startContainer;
   offset = startOffset + text.length;
32522
 } else if (startContainer === this.content && endContainer === this.content) {
   var textNode = document.createTextNode(text);
32525
   this.content.insertBefore(textNode, childNodesArray[startOffset]);
32527
   container = textNode;
   offset = textNode.textContent.length;
 } else {
   var startContainerChildIndex = childNodesArray.indexOf(startContainer),
       endContainerChildIndex = childNodesArray.indexOf(endContainer);
32533
   childNodesArray.forEach(function(childNode, index) {
32535
     if (index === startContainerChildIndex) {
       childNode.textContent =
         startContainer.textContent.substring(0, startOffset) +
         text +
         endContainer.textContent.substring(endOffset);
     } else if (index > startContainerChildIndex && index <= endContainerChildIndex) {
       remove$3(childNode);
     }
   });
32545
   container = startContainer;
   offset = startOffset + text.length;
 }
32549
 if (container && offset !== undefined) {
32551
   // is necessary in Internet Explorer
   setTimeout(function() {
     self.setSelection(container, offset);
   });
 }
};
32558
/**
* Automatically resize element vertically to fit its content.
*/
TextBox.prototype.autoResize = function() {
 var parent = this.parent,
     content = this.content;
32565
 var fontSize = parseInt(this.style.fontSize) || 12;
32567
 if (content.scrollHeight > parent.offsetHeight ||
     content.scrollHeight < parent.offsetHeight - fontSize) {
   var bounds = parent.getBoundingClientRect();
32571
   var height = content.scrollHeight;
   parent.style.height = height + 'px';
32574
   this.resizeHandler({
     width: bounds.width,
     height: bounds.height,
     dx: 0,
     dy: height - bounds.height
   });
 }
};
32583
/**
* Make an element resizable by adding a resize handle.
*/
TextBox.prototype.resizable = function() {
 var self = this;
32589
 var parent = this.parent,
     resizeHandle = this.resizeHandle;
32592
 var minWidth = parseInt(this.style.minWidth) || 0,
     minHeight = parseInt(this.style.minHeight) || 0,
     maxWidth = parseInt(this.style.maxWidth) || Infinity,
     maxHeight = parseInt(this.style.maxHeight) || Infinity;
32597
 if (!resizeHandle) {
   resizeHandle = this.resizeHandle = domify$1(
     '<div class="djs-direct-editing-resize-handle"></div>'
   );
32602
   var startX, startY, startWidth, startHeight;
32604
   var onMouseDown = function(e) {
     preventDefault(e);
     stopPropagation(e);
32608
     startX = e.clientX;
     startY = e.clientY;
32611
     var bounds = parent.getBoundingClientRect();
32613
     startWidth = bounds.width;
     startHeight = bounds.height;
32616
     componentEvent$1.bind(document, 'mousemove', onMouseMove);
     componentEvent$1.bind(document, 'mouseup', onMouseUp);
   };
32620
   var onMouseMove = function(e) {
     preventDefault(e);
     stopPropagation(e);
32624
     var newWidth = min$3(max$5(startWidth + e.clientX - startX, minWidth), maxWidth);
     var newHeight = min$3(max$5(startHeight + e.clientY - startY, minHeight), maxHeight);
32627
     parent.style.width = newWidth + 'px';
     parent.style.height = newHeight + 'px';
32630
     self.resizeHandler({
       width: startWidth,
       height: startHeight,
       dx: e.clientX - startX,
       dy: e.clientY - startY
     });
   };
32638
   var onMouseUp = function(e) {
     preventDefault(e);
     stopPropagation(e);
32642
     componentEvent$1.unbind(document,'mousemove', onMouseMove, false);
     componentEvent$1.unbind(document, 'mouseup', onMouseUp, false);
   };
32646
   componentEvent$1.bind(resizeHandle, 'mousedown', onMouseDown);
 }
32649
 assign(resizeHandle.style, {
   position: 'absolute',
   bottom: '0px',
   right: '0px',
   cursor: 'nwse-resize',
   width: '0',
   height: '0',
   borderTop: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid transparent',
   borderRight: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid #ccc',
   borderBottom: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid #ccc',
   borderLeft: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid transparent'
 });
32662
 parent.appendChild(resizeHandle);
};
32665
32666
/**
* Clear content and style of the textbox, unbind listeners and
* reset CSS style.
*/
TextBox.prototype.destroy = function() {
 var parent = this.parent,
     content = this.content,
     resizeHandle = this.resizeHandle;
32675
 // clear content
 content.innerText = '';
32678
 // clear styles
 parent.removeAttribute('style');
 content.removeAttribute('style');
32682
 componentEvent$1.unbind(content, 'keydown', this.keyHandler);
 componentEvent$1.unbind(content, 'mousedown', stopPropagation);
 componentEvent$1.unbind(content, 'input', this.autoResize);
 componentEvent$1.unbind(content, 'paste', this.handlePaste);
32687
 if (resizeHandle) {
   resizeHandle.removeAttribute('style');
32690
   remove$3(resizeHandle);
 }
32693
 remove$3(parent);
};
32696
32697
TextBox.prototype.getValue = function() {
 return this.content.innerText.trim();
};
32701
32702
TextBox.prototype.getSelection = function() {
 var selection = window.getSelection(),
     range = selection.getRangeAt(0);
32706
 return range;
};
32709
32710
TextBox.prototype.setSelection = function(container, offset) {
 var range = document.createRange();
32713
 if (container === null) {
   range.selectNodeContents(this.content);
 } else {
   range.setStart(container, offset);
   range.setEnd(container, offset);
 }
32720
 var selection = window.getSelection();
32722
 selection.removeAllRanges();
 selection.addRange(range);
};
32726
// helpers //////////
32728
function normalizeEndOfLineSequences(string) {
 return string.replace(/\r\n|\r|\n/g, '\n');
}
32732
/**
* A direct editing component that allows users
* to edit an elements text directly in the diagram
*
* @param {EventBus} eventBus the event bus
*/
function DirectEditing(eventBus, canvas) {
32740
 this._eventBus = eventBus;
32742
 this._providers = [];
 this._textbox = new TextBox({
   container: canvas.getContainer(),
   keyHandler: bind(this._handleKey, this),
   resizeHandler: bind(this._handleResize, this)
 });
}
32750
DirectEditing.$inject = [ 'eventBus', 'canvas' ];
32752
32753
/**
* Register a direct editing provider
32756
* @param {Object} provider the provider, must expose an #activate(element) method that returns
*                          an activation context ({ bounds: {x, y, width, height }, text }) if
*                          direct editing is available for the given element.
*                          Additionally the provider must expose a #update(element, value) method
*                          to receive direct editing updates.
*/
DirectEditing.prototype.registerProvider = function(provider) {
 this._providers.push(provider);
};
32766
32767
/**
* Returns true if direct editing is currently active
*
* @return {Boolean}
*/
DirectEditing.prototype.isActive = function() {
 return !!this._active;
};
32776
32777
/**
* Cancel direct editing, if it is currently active
*/
DirectEditing.prototype.cancel = function() {
 if (!this._active) {
   return;
 }
32785
 this._fire('cancel');
 this.close();
};
32789
32790
DirectEditing.prototype._fire = function(event, context) {
 this._eventBus.fire('directEditing.' + event, context || { active: this._active });
};
32794
DirectEditing.prototype.close = function() {
 this._textbox.destroy();
32797
 this._fire('deactivate');
32799
 this._active = null;
32801
 this.resizable = undefined;
};
32804
32805
DirectEditing.prototype.complete = function() {
32807
 var active = this._active;
32809
 if (!active) {
   return;
 }
32813
 var containerBounds,
     previousBounds = active.context.bounds,
     newBounds = this.$textbox.getBoundingClientRect(),
     newText = this.getValue(),
     previousText = active.context.text;
32819
 if (
   newText !== previousText ||
   newBounds.height !== previousBounds.height ||
   newBounds.width !== previousBounds.width
 ) {
   containerBounds = this._textbox.container.getBoundingClientRect();
32826
   active.provider.update(active.element, newText, active.context.text, {
     x: newBounds.left - containerBounds.left,
     y: newBounds.top - containerBounds.top,
     width: newBounds.width,
     height: newBounds.height
   });
 }
32834
 this._fire('complete');
32836
 this.close();
};
32839
32840
DirectEditing.prototype.getValue = function() {
 return this._textbox.getValue();
};
32844
32845
DirectEditing.prototype._handleKey = function(e) {
32847
 // stop bubble
 e.stopPropagation();
32850
 var key = e.keyCode || e.charCode;
32852
 // ESC
 if (key === 27) {
   e.preventDefault();
   return this.cancel();
 }
32858
 // Enter
 if (key === 13 && !e.shiftKey) {
   e.preventDefault();
   return this.complete();
 }
};
32865
32866
DirectEditing.prototype._handleResize = function(event) {
 this._fire('resize', event);
};
32870
32871
/**
* Activate direct editing on the given element
*
* @param {Object} ElementDescriptor the descriptor for a shape or connection
* @return {Boolean} true if the activation was possible
*/
DirectEditing.prototype.activate = function(element) {
 if (this.isActive()) {
   this.cancel();
 }
32882
 // the direct editing context
 var context;
32885
 var provider = find(this._providers, function(p) {
   return (context = p.activate(element)) ? p : null;
 });
32889
 // check if activation took place
 if (context) {
   this.$textbox = this._textbox.create(
     context.bounds,
     context.style,
     context.text,
     context.options
   );
32898
   this._active = {
     element: element,
     context: context,
     provider: provider
   };
32904
   if (context.options && context.options.resizable) {
     this.resizable = true;
   }
32908
   this._fire('activate');
 }
32911
 return !!context;
};
32914
var DirectEditingModule = {
 __depends__: [
   InteractionEventsModule$1
 ],
 __init__: [ 'directEditing' ],
 directEditing: [ 'type', DirectEditing ]
};
32922
var entrySelector = '.entry';
32924
var DEFAULT_PRIORITY$2 = 1000;
32926
32927
/**
* A context pad that displays element specific, contextual actions next
* to a diagram element.
*
* @param {Object} config
* @param {boolean|Object} [config.scale={ min: 1.0, max: 1.5 }]
* @param {number} [config.scale.min]
* @param {number} [config.scale.max]
* @param {EventBus} eventBus
* @param {Overlays} overlays
*/
function ContextPad(config, eventBus, overlays) {
32940
 this._eventBus = eventBus;
 this._overlays = overlays;
32943
 var scale = isDefined(config && config.scale) ? config.scale : {
   min: 1,
   max: 1.5
 };
32948
 this._overlaysConfig = {
   position: {
     right: -9,
     top: -6
   },
   scale: scale
 };
32956
 this._current = null;
32958
 this._init();
}
32961
ContextPad.$inject = [
 'config.contextPad',
 'eventBus',
 'overlays'
];
32967
32968
/**
* Registers events needed for interaction with other components
*/
ContextPad.prototype._init = function() {
32973
 var eventBus = this._eventBus;
32975
 var self = this;
32977
 eventBus.on('selection.changed', function(e) {
32979
   var selection = e.newSelection;
32981
   if (selection.length === 1) {
     self.open(selection[0]);
   } else {
     self.close();
   }
 });
32988
 eventBus.on('elements.delete', function(event) {
   var elements = event.elements;
32991
   forEach$2(elements, function(e) {
     if (self.isOpen(e)) {
       self.close();
     }
   });
 });
32998
 eventBus.on('element.changed', function(event) {
   var element = event.element,
       current = self._current;
33002
   // force reopen if element for which we are currently opened changed
   if (current && current.element === element) {
     self.open(element, true);
   }
 });
};
33009
33010
/**
* Register a provider with the context pad
*
* @param  {number} [priority=1000]
* @param  {ContextPadProvider} provider
*
* @example
* const contextPadProvider = {
 *   getContextPadEntries: function(element) {
 *     return function(entries) {
 *       return {
 *         ...entries,
 *         'entry-1': {
 *           label: 'My Entry',
 *           action: function() { alert("I have been clicked!"); }
 *         }
 *       };
 *     }
 *   }
 * };
 *
* contextPad.registerProvider(800, contextPadProvider);
*/
ContextPad.prototype.registerProvider = function(priority, provider) {
 if (!provider) {
   provider = priority;
   priority = DEFAULT_PRIORITY$2;
 }
33039
 this._eventBus.on('contextPad.getProviders', priority, function(event) {
   event.providers.push(provider);
 });
};
33044
33045
/**
* Returns the context pad entries for a given element
*
* @param {djs.element.Base} element
*
* @return {Array<ContextPadEntryDescriptor>} list of entries
*/
ContextPad.prototype.getEntries = function(element) {
 var providers = this._getProviders();
33055
 var entries = {};
33057
 // loop through all providers and their entries.
 // group entries by id so that overriding an entry is possible
 forEach$2(providers, function(provider) {
   var entriesOrUpdater = provider.getContextPadEntries(element);
33062
   if (isFunction(entriesOrUpdater)) {
     entries = entriesOrUpdater(entries);
   } else {
     forEach$2(entriesOrUpdater, function(entry, id) {
       entries[id] = entry;
     });
   }
 });
33071
 return entries;
};
33074
33075
/**
* Trigger an action available on the opened context pad
*
* @param  {string} action
* @param  {Event} event
* @param  {boolean} [autoActivate=false]
*/
ContextPad.prototype.trigger = function(action, event, autoActivate) {
33084
 var element = this._current.element,
     entries = this._current.entries,
     entry,
     handler,
     originalEvent,
     button = event.delegateTarget || event.target;
33091
 if (!button) {
   return event.preventDefault();
 }
33095
 entry = entries[attr(button, 'data-action')];
 handler = entry.action;
33098
 originalEvent = event.originalEvent || event;
33100
 // simple action (via callback function)
 if (isFunction(handler)) {
   if (action === 'click') {
     return handler(originalEvent, element, autoActivate);
   }
 } else {
   if (handler[action]) {
     return handler[action](originalEvent, element, autoActivate);
   }
 }
33111
 // silence other actions
 event.preventDefault();
};
33115
33116
/**
* Open the context pad for the given element
*
* @param {djs.model.Base} element
* @param {boolean} force if true, force reopening the context pad
*/
ContextPad.prototype.open = function(element, force) {
 if (!force && this.isOpen(element)) {
   return;
 }
33127
 this.close();
 this._updateAndOpen(element);
};
33131
ContextPad.prototype._getProviders = function() {
33133
 var event = this._eventBus.createEvent({
   type: 'contextPad.getProviders',
   providers: []
 });
33138
 this._eventBus.fire(event);
33140
 return event.providers;
};
33143
ContextPad.prototype._updateAndOpen = function(element) {
33145
 var entries = this.getEntries(element),
     pad = this.getPad(element),
     html = pad.html;
33149
 forEach$2(entries, function(entry, id) {
   var grouping = entry.group || 'default',
       control = domify(entry.html || '<div class="entry" draggable="true"></div>'),
       container;
33154
   attr(control, 'data-action', id);
33156
   container = query('[data-group=' + grouping + ']', html);
   if (!container) {
     container = domify('<div class="group" data-group="' + grouping + '"></div>');
     html.appendChild(container);
   }
33162
   container.appendChild(control);
33164
   if (entry.className) {
     addClasses$1(control, entry.className);
   }
33168
   if (entry.title) {
     attr(control, 'title', entry.title);
   }
33172
   if (entry.imageUrl) {
     control.appendChild(domify('<img src="' + entry.imageUrl + '">'));
   }
 });
33177
 classes(html).add('open');
33179
 this._current = {
   element: element,
   pad: pad,
   entries: entries
 };
33185
 this._eventBus.fire('contextPad.open', { current: this._current });
};
33188
33189
ContextPad.prototype.getPad = function(element) {
 if (this.isOpen()) {
   return this._current.pad;
 }
33194
 var self = this;
33196
 var overlays = this._overlays;
33198
 var html = domify('<div class="djs-context-pad"></div>');
33200
 var overlaysConfig = assign({
   html: html
 }, this._overlaysConfig);
33204
 delegate.bind(html, entrySelector, 'click', function(event) {
   self.trigger('click', event);
 });
33208
 delegate.bind(html, entrySelector, 'dragstart', function(event) {
   self.trigger('dragstart', event);
 });
33212
 // stop propagation of mouse events
 componentEvent.bind(html, 'mousedown', function(event) {
   event.stopPropagation();
 });
33217
 this._overlayId = overlays.add(element, 'context-pad', overlaysConfig);
33219
 var pad = overlays.get(this._overlayId);
33221
 this._eventBus.fire('contextPad.create', { element: element, pad: pad });
33223
 return pad;
};
33226
33227
/**
* Close the context pad
*/
ContextPad.prototype.close = function() {
 if (!this.isOpen()) {
   return;
 }
33235
 this._overlays.remove(this._overlayId);
33237
 this._overlayId = null;
33239
 this._eventBus.fire('contextPad.close', { current: this._current });
33241
 this._current = null;
};
33244
/**
* Check if pad is open. If element is given, will check
* if pad is opened with given element.
*
* @param {Element} element
* @return {boolean}
*/
ContextPad.prototype.isOpen = function(element) {
 return !!this._current && (!element ? true : this._current.element === element);
};
33255
33256
33257
33258
// helpers //////////////////////
33260
function addClasses$1(element, classNames) {
33262
 var classes$1 = classes(element);
33264
 var actualClassNames = isArray$4(classNames) ? classNames : classNames.split(/\s+/g);
 actualClassNames.forEach(function(cls) {
   classes$1.add(cls);
 });
}
33270
var ContextPadModule$1 = {
 __depends__: [
   InteractionEventsModule$1,
   OverlaysModule
 ],
 contextPad: [ 'type', ContextPad ]
};
33278
var MARKER_TYPES = [
 'marker-start',
 'marker-mid',
 'marker-end'
];
33284
var NODES_CAN_HAVE_MARKER = [
 'circle',
 'ellipse',
 'line',
 'path',
 'polygon',
 'polyline',
 'rect'
];
33294
33295
/**
* Adds support for previews of moving/resizing elements.
*/
function PreviewSupport(elementRegistry, eventBus, canvas, styles) {
 this._elementRegistry = elementRegistry;
 this._canvas = canvas;
 this._styles = styles;
33303
 this._clonedMarkers = {};
33305
 var self = this;
33307
 eventBus.on('drag.cleanup', function() {
   forEach$2(self._clonedMarkers, function(clonedMarker) {
     remove$2(clonedMarker);
   });
33312
   self._clonedMarkers = {};
 });
}
33316
PreviewSupport.$inject = [
 'elementRegistry',
 'eventBus',
 'canvas',
 'styles'
];
33323
33324
/**
* Returns graphics of an element.
*
* @param {djs.model.Base} element
*
* @return {SVGElement}
*/
PreviewSupport.prototype.getGfx = function(element) {
 return this._elementRegistry.getGraphics(element);
};
33335
/**
* Adds a move preview of a given shape to a given svg group.
*
* @param {djs.model.Base} element
* @param {SVGElement} group
* @param {SVGElement} [gfx]
*
* @return {SVGElement} dragger
*/
PreviewSupport.prototype.addDragger = function(element, group, gfx) {
 gfx = gfx || this.getGfx(element);
33347
 var dragger = clone$1(gfx);
 var bbox = gfx.getBoundingClientRect();
33350
 this._cloneMarkers(getVisual(dragger));
33352
 attr$1(dragger, this._styles.cls('djs-dragger', [], {
   x: bbox.top,
   y: bbox.left
 }));
33357
 append(group, dragger);
33359
 return dragger;
};
33362
/**
* Adds a resize preview of a given shape to a given svg group.
*
* @param {djs.model.Base} element
* @param {SVGElement} group
*
* @return {SVGElement} frame
*/
PreviewSupport.prototype.addFrame = function(shape, group) {
33372
 var frame = create$1('rect', {
   class: 'djs-resize-overlay',
   width:  shape.width,
   height: shape.height,
   x: shape.x,
   y: shape.y
 });
33380
 append(group, frame);
33382
 return frame;
};
33385
/**
* Clone all markers referenced by a node and its child nodes.
*
* @param {SVGElement} gfx
*/
PreviewSupport.prototype._cloneMarkers = function(gfx) {
 var self = this;
33393
 if (gfx.childNodes) {
33395
   // TODO: use forEach once we drop PhantomJS
   for (var i = 0; i < gfx.childNodes.length; i++) {
33398
     // recursively clone markers of child nodes
     self._cloneMarkers(gfx.childNodes[ i ]);
   }
 }
33403
 if (!canHaveMarker(gfx)) {
   return;
 }
33407
 MARKER_TYPES.forEach(function(markerType) {
   if (attr$1(gfx, markerType)) {
     var marker = getMarker(gfx, markerType, self._canvas.getContainer());
33411
     self._cloneMarker(gfx, marker, markerType);
   }
 });
};
33416
/**
* Clone marker referenced by an element.
*
* @param {SVGElement} gfx
* @param {SVGElement} marker
* @param {string} markerType
*/
PreviewSupport.prototype._cloneMarker = function(gfx, marker, markerType) {
 var markerId = marker.id;
33426
 var clonedMarker = this._clonedMarkers[ markerId ];
33428
 if (!clonedMarker) {
   clonedMarker = clone$1(marker);
33431
   var clonedMarkerId = markerId + '-clone';
33433
   clonedMarker.id = clonedMarkerId;
33435
   classes$1(clonedMarker)
     .add('djs-dragger')
     .add('djs-dragger-marker');
33439
   this._clonedMarkers[ markerId ] = clonedMarker;
33441
   var defs = query('defs', this._canvas._svg);
33443
   if (!defs) {
     defs = create$1('defs');
33446
     append(this._canvas._svg, defs);
   }
33449
   append(defs, clonedMarker);
 }
33452
 var reference = idToReference(this._clonedMarkers[ markerId ].id);
33454
 attr$1(gfx, markerType, reference);
};
33457
// helpers //////////
33459
/**
* Get marker of given type referenced by node.
*
* @param {Node} node
* @param {string} markerType
* @param {Node} [parentNode]
*
* @param {Node}
*/
function getMarker(node, markerType, parentNode) {
 var id = referenceToId(attr$1(node, markerType));
33471
 return query('marker#' + id, parentNode || document);
}
33474
/**
* Get ID of fragment within current document from its functional IRI reference.
* References may use single or double quotes.
*
* @param {string} reference
*
* @returns {string}
*/
function referenceToId(reference) {
 return reference.match(/url\(['"]?#([^'"]*)['"]?\)/)[1];
}
33486
/**
* Get functional IRI reference for given ID of fragment within current document.
*
* @param {string} id
*
* @returns {string}
*/
function idToReference(id) {
 return 'url(#' + id + ')';
}
33497
/**
* Check wether node type can have marker attributes.
*
* @param {Node} node
*
* @returns {boolean}
*/
function canHaveMarker(node) {
 return NODES_CAN_HAVE_MARKER.indexOf(node.nodeName) !== -1;
}
33508
var PreviewSupportModule = {
 __init__: [ 'previewSupport' ],
 previewSupport: [ 'type', PreviewSupport ]
};
33513
var MARKER_OK$2 = 'drop-ok',
   MARKER_NOT_OK$2 = 'drop-not-ok',
   MARKER_ATTACH$2 = 'attach-ok',
   MARKER_NEW_PARENT$1 = 'new-parent';
33518
var PREFIX = 'create';
33520
var HIGH_PRIORITY$h = 2000;
33522
33523
/**
* Create new elements through drag and drop.
*
* @param {Canvas} canvas
* @param {Dragging} dragging
* @param {EventBus} eventBus
* @param {Modeling} modeling
* @param {Rules} rules
*/
function Create(
   canvas,
   dragging,
   eventBus,
   modeling,
   rules
) {
33540
 // rules //////////
33542
 /**
  * Check wether elements can be created.
  *
  * @param {Array<djs.model.Base>} elements
  * @param {djs.model.Base} target
  * @param {Point} position
  * @param {djs.model.Base} [source]
  *
  * @returns {boolean|null|Object}
  */
 function canCreate(elements, target, position, source, hints) {
   if (!target) {
     return false;
   }
33557
   // ignore child elements and external labels
   elements = filter(elements, function(element) {
     var labelTarget = element.labelTarget;
33561
     return !element.parent && !(isLabel$5(element) && elements.indexOf(labelTarget) !== -1);
   });
33564
   var shape = find(elements, function(element) {
     return !isConnection$b(element);
   });
33568
   var attach = false,
       connect = false,
       create = false;
33572
   // (1) attaching single shapes
   if (isSingleShape(elements)) {
     attach = rules.allowed('shape.attach', {
       position: position,
       shape: shape,
       target: target
     });
   }
33581
   if (!attach) {
33583
     // (2) creating elements
     if (isSingleShape(elements)) {
       create = rules.allowed('shape.create', {
         position: position,
         shape: shape,
         source: source,
         target: target
       });
     } else {
       create = rules.allowed('elements.create', {
         elements: elements,
         position: position,
         target: target
       });
     }
33599
   }
33601
   var connectionTarget = hints.connectionTarget;
33603
   // (3) appending single shapes
   if (create || attach) {
     if (shape && source) {
       connect = rules.allowed('connection.create', {
         source: connectionTarget === source ? shape : source,
         target: connectionTarget === source ? source : shape,
         hints: {
           targetParent: target,
           targetAttach: attach
         }
       });
     }
33616
     return {
       attach: attach,
       connect: connect
     };
   }
33622
   // ignore wether or not elements can be created
   if (create === null || attach === null) {
     return null;
   }
33627
   return false;
 }
33630
 function setMarker(element, marker) {
   [ MARKER_ATTACH$2, MARKER_OK$2, MARKER_NOT_OK$2, MARKER_NEW_PARENT$1 ].forEach(function(m) {
33633
     if (m === marker) {
       canvas.addMarker(element, m);
     } else {
       canvas.removeMarker(element, m);
     }
   });
 }
33641
 // event handling //////////
33643
 eventBus.on([ 'create.move', 'create.hover' ], function(event) {
   var context = event.context,
       elements = context.elements,
       hover = event.hover,
       source = context.source,
       hints = context.hints || {};
33650
   if (!hover) {
     context.canExecute = false;
     context.target = null;
33654
     return;
   }
33657
   ensureConstraints$2(event);
33659
   var position = {
     x: event.x,
     y: event.y
   };
33664
   var canExecute = context.canExecute = hover && canCreate(elements, hover, position, source, hints);
33666
   if (hover && canExecute !== null) {
     context.target = hover;
33669
     if (canExecute && canExecute.attach) {
       setMarker(hover, MARKER_ATTACH$2);
     } else {
       setMarker(hover, canExecute ? MARKER_NEW_PARENT$1 : MARKER_NOT_OK$2);
     }
   }
 });
33677
 eventBus.on([ 'create.end', 'create.out', 'create.cleanup' ], function(event) {
   var hover = event.hover;
33680
   if (hover) {
     setMarker(hover, null);
   }
 });
33685
 eventBus.on('create.end', function(event) {
   var context = event.context,
       source = context.source,
       shape = context.shape,
       elements = context.elements,
       target = context.target,
       canExecute = context.canExecute,
       attach = canExecute && canExecute.attach,
       connect = canExecute && canExecute.connect,
       hints = context.hints || {};
33696
   if (canExecute === false || !target) {
     return false;
   }
33700
   ensureConstraints$2(event);
33702
   var position = {
     x: event.x,
     y: event.y
   };
33707
   if (connect) {
     shape = modeling.appendShape(source, shape, position, target, {
       attach: attach,
       connection: connect === true ? {} : connect,
       connectionTarget: hints.connectionTarget
     });
   } else {
     elements = modeling.createElements(elements, position, target, assign({}, hints, {
       attach: attach
     }));
33718
     // update shape
     shape = find(elements, function(element) {
       return !isConnection$b(element);
     });
   }
33724
   // update elements and shape
   assign(context, {
     elements: elements,
     shape: shape
   });
33730
   assign(event, {
     elements: elements,
     shape: shape
   });
 });
33736
 function cancel() {
   var context = dragging.context();
33739
   if (context && context.prefix === PREFIX) {
     dragging.cancel();
   }
 }
33744
 // cancel on <elements.changed> that is not result of <drag.end>
 eventBus.on('create.init', function() {
   eventBus.on('elements.changed', cancel);
33748
   eventBus.once([ 'create.cancel', 'create.end' ], HIGH_PRIORITY$h, function() {
     eventBus.off('elements.changed', cancel);
   });
 });
33753
 // API //////////
33755
 this.start = function(event, elements, context) {
   if (!isArray$4(elements)) {
     elements = [ elements ];
   }
33760
   var shape = find(elements, function(element) {
     return !isConnection$b(element);
   });
33764
   if (!shape) {
33766
     // at least one shape is required
     return;
   }
33770
   context = assign({
     elements: elements,
     hints: {},
     shape: shape
   }, context || {});
33776
   // make sure each element has x and y
   forEach$2(elements, function(element) {
     if (!isNumber(element.x)) {
       element.x = 0;
     }
33782
     if (!isNumber(element.y)) {
       element.y = 0;
     }
   });
33787
   var visibleElements = filter(elements, function(element) {
     return !element.hidden;
   });
33791
   var bbox = getBBox(visibleElements);
33793
   // center elements around cursor
   forEach$2(elements, function(element) {
     if (isConnection$b(element)) {
       element.waypoints = map(element.waypoints, function(waypoint) {
         return {
           x: waypoint.x - bbox.x - bbox.width / 2,
           y: waypoint.y - bbox.y - bbox.height / 2
         };
       });
     }
33804
     assign(element, {
       x: element.x - bbox.x - bbox.width / 2,
       y: element.y - bbox.y - bbox.height / 2
     });
   });
33810
   dragging.init(event, PREFIX, {
     cursor: 'grabbing',
     autoActivate: true,
     data: {
       shape: shape,
       elements: elements,
       context: context
     }
   });
 };
}
33822
Create.$inject = [
 'canvas',
 'dragging',
 'eventBus',
 'modeling',
 'rules'
];
33830
// helpers //////////
33832
function ensureConstraints$2(event) {
 var context = event.context,
     createConstraints = context.createConstraints;
33836
 if (!createConstraints) {
   return;
 }
33840
 if (createConstraints.left) {
   event.x = Math.max(event.x, createConstraints.left);
 }
33844
 if (createConstraints.right) {
   event.x = Math.min(event.x, createConstraints.right);
 }
33848
 if (createConstraints.top) {
   event.y = Math.max(event.y, createConstraints.top);
 }
33852
 if (createConstraints.bottom) {
   event.y = Math.min(event.y, createConstraints.bottom);
 }
}
33857
function isConnection$b(element) {
 return !!element.waypoints;
}
33861
function isSingleShape(elements) {
 return elements && elements.length === 1 && !isConnection$b(elements[0]);
}
33865
function isLabel$5(element) {
 return !!element.labelTarget;
}
33869
var LOW_PRIORITY$h = 750;
33871
33872
function CreatePreview(
   canvas,
   eventBus,
   graphicsFactory,
   previewSupport,
   styles
) {
 function createDragGroup(elements) {
   var dragGroup = create$1('g');
33882
   attr$1(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));
33884
   var childrenGfx = create$1('g');
33886
   elements.forEach(function(element) {
33888
     // create graphics
     var gfx;
33891
     if (element.hidden) {
       return;
     }
33895
     if (element.waypoints) {
       gfx = graphicsFactory._createContainer('connection', childrenGfx);
33898
       graphicsFactory.drawConnection(getVisual(gfx), element);
     } else {
       gfx = graphicsFactory._createContainer('shape', childrenGfx);
33902
       graphicsFactory.drawShape(getVisual(gfx), element);
33904
       translate$2(gfx, element.x, element.y);
     }
33907
     // add preview
     previewSupport.addDragger(element, dragGroup, gfx);
   });
33911
   return dragGroup;
 }
33914
 eventBus.on('create.move', LOW_PRIORITY$h, function(event) {
33916
   var hover = event.hover,
       context = event.context,
       elements = context.elements,
       dragGroup = context.dragGroup;
33921
   // lazily create previews
   if (!dragGroup) {
     dragGroup = context.dragGroup = createDragGroup(elements);
   }
33926
   var activeLayer;
33928
   if (hover) {
     if (!dragGroup.parentNode) {
       activeLayer = canvas.getActiveLayer();
33932
       append(activeLayer, dragGroup);
     }
33935
     translate$2(dragGroup, event.x, event.y);
   } else {
     remove$2(dragGroup);
   }
 });
33941
 eventBus.on('create.cleanup', function(event) {
   var context = event.context,
       dragGroup = context.dragGroup;
33945
   if (dragGroup) {
     remove$2(dragGroup);
   }
 });
}
33951
CreatePreview.$inject = [
 'canvas',
 'eventBus',
 'graphicsFactory',
 'previewSupport',
 'styles'
];
33959
var CreateModule = {
 __depends__: [
   DraggingModule,
   PreviewSupportModule,
   RulesModule$1,
   SelectionModule
 ],
 __init__: [
   'create',
   'createPreview'
 ],
 create: [ 'type', Create ],
 createPreview: [ 'type', CreatePreview ]
};
33974
var DATA_REF = 'data-id';
33976
var CLOSE_EVENTS = [
 'contextPad.close',
 'canvas.viewbox.changing',
 'commandStack.changed'
];
33982
var DEFAULT_PRIORITY$1 = 1000;
33984
33985
/**
* A popup menu that can be used to display a list of actions anywhere in the canvas.
*
* @param {Object} config
* @param {boolean|Object} [config.scale={ min: 1.0, max: 1.5 }]
* @param {number} [config.scale.min]
* @param {number} [config.scale.max]
* @param {EventBus} eventBus
* @param {Canvas} canvas
*
* @class
* @constructor
*/
function PopupMenu(config, eventBus, canvas) {
34000
 var scale = isDefined(config && config.scale) ? config.scale : {
   min: 1,
   max: 1.5
 };
34005
 this._config = {
   scale: scale
 };
34009
 this._eventBus = eventBus;
 this._canvas = canvas;
 this._providers = {};
 this._current = {};
}
34015
PopupMenu.$inject = [
 'config.popupMenu',
 'eventBus',
 'canvas'
];
34021
/**
* Registers a popup menu provider
*
* @param  {string} id
* @param {number} [priority=1000]
* @param  {Object} provider
*
* @example
* const popupMenuProvider = {
*   getPopupMenuEntries: function(element) {
*     return {
*       'entry-1': {
*         label: 'My Entry',
*         action: function() { alert("I have been clicked!"); }
*       }
*     }
*   }
* };
*
* popupMenu.registerProvider('myMenuID', popupMenuProvider);
*/
PopupMenu.prototype.registerProvider = function(id, priority, provider) {
 if (!provider) {
   provider = priority;
   priority = DEFAULT_PRIORITY$1;
 }
34048
 this._eventBus.on('popupMenu.getProviders.' + id, priority, function(event) {
   event.providers.push(provider);
 });
};
34053
/**
* Determine if the popup menu has entries.
*
* @return {boolean} true if empty
*/
PopupMenu.prototype.isEmpty = function(element, providerId) {
 if (!element) {
   throw new Error('element parameter is missing');
 }
34063
 if (!providerId) {
   throw new Error('providerId parameter is missing');
 }
34067
 var providers = this._getProviders(providerId);
34069
 if (!providers) {
   return true;
 }
34073
 var entries = this._getEntries(element, providers),
     headerEntries = this._getHeaderEntries(element, providers);
34076
 var hasEntries = size(entries) > 0,
     hasHeaderEntries = headerEntries && size(headerEntries) > 0;
34079
 return !hasEntries && !hasHeaderEntries;
};
34082
34083
/**
* Create entries and open popup menu at given position
*
* @param  {Object} element
* @param  {string} id provider id
* @param  {Object} position
*
* @return {Object} popup menu instance
*/
PopupMenu.prototype.open = function(element, id, position) {
34094
 var providers = this._getProviders(id);
34096
 if (!element) {
   throw new Error('Element is missing');
 }
34100
 if (!providers || !providers.length) {
   throw new Error('No registered providers for: ' + id);
 }
34104
 if (!position) {
   throw new Error('the position argument is missing');
 }
34108
 if (this.isOpen()) {
   this.close();
 }
34112
 this._emit('open');
34114
 var current = this._current = {
   className: id,
   element: element,
   position: position
 };
34120
 var entries = this._getEntries(element, providers),
     headerEntries = this._getHeaderEntries(element, providers);
34123
 current.entries = assign({}, entries, headerEntries);
34125
 current.container = this._createContainer();
34127
 if (size(headerEntries)) {
   current.container.appendChild(
     this._createEntries(headerEntries, 'djs-popup-header')
   );
 }
34133
 if (size(entries)) {
   current.container.appendChild(
     this._createEntries(entries, 'djs-popup-body')
   );
 }
34139
 var canvas = this._canvas,
     parent = canvas.getContainer();
34142
 this._attachContainer(current.container, parent, position.cursor);
 this._bindAutoClose();
};
34146
34147
/**
* Removes the popup menu and unbinds the event handlers.
*/
PopupMenu.prototype.close = function() {
34152
 if (!this.isOpen()) {
   return;
 }
34156
 this._emit('close');
34158
 this._unbindAutoClose();
 remove$1(this._current.container);
 this._current.container = null;
};
34163
34164
/**
* Determine if an open popup menu exist.
*
* @return {boolean} true if open
*/
PopupMenu.prototype.isOpen = function() {
 return !!this._current.container;
};
34173
34174
/**
* Trigger an action associated with an entry.
*
* @param {Object} event
*
* @return the result of the action callback, if any
*/
PopupMenu.prototype.trigger = function(event) {
34183
 // silence other actions
 event.preventDefault();
34186
 var element = event.delegateTarget || event.target,
     entryId = attr(element, DATA_REF);
34189
 var entry = this._getEntry(entryId);
34191
 if (entry.action) {
   return entry.action.call(null, event, entry);
 }
};
34196
PopupMenu.prototype._getProviders = function(id) {
34198
 var event = this._eventBus.createEvent({
   type: 'popupMenu.getProviders.' + id,
   providers: []
 });
34203
 this._eventBus.fire(event);
34205
 return event.providers;
};
34208
PopupMenu.prototype._getEntries = function(element, providers) {
34210
 var entries = {};
34212
 forEach$2(providers, function(provider) {
34214
   // handle legacy method
   if (!provider.getPopupMenuEntries) {
     forEach$2(provider.getEntries(element), function(entry) {
       var id = entry.id;
34219
       if (!id) {
         throw new Error('every entry must have the id property set');
       }
34223
       entries[id] = omit(entry, [ 'id' ]);
     });
34226
     return;
   }
34229
   var entriesOrUpdater = provider.getPopupMenuEntries(element);
34231
   if (isFunction(entriesOrUpdater)) {
     entries = entriesOrUpdater(entries);
   } else {
     forEach$2(entriesOrUpdater, function(entry, id) {
       entries[id] = entry;
     });
   }
 });
34240
 return entries;
};
34243
PopupMenu.prototype._getHeaderEntries = function(element, providers) {
34245
 var entries = {};
34247
 forEach$2(providers, function(provider) {
34249
   // handle legacy method
   if (!provider.getPopupMenuHeaderEntries) {
     if (!provider.getHeaderEntries) {
       return;
     }
34255
     forEach$2(provider.getHeaderEntries(element), function(entry) {
       var id = entry.id;
34258
       if (!id) {
         throw new Error('every entry must have the id property set');
       }
34262
       entries[id] = omit(entry, [ 'id' ]);
     });
34265
     return;
   }
34268
   var entriesOrUpdater = provider.getPopupMenuHeaderEntries(element);
34270
   if (isFunction(entriesOrUpdater)) {
     entries = entriesOrUpdater(entries);
   } else {
     forEach$2(entriesOrUpdater, function(entry, id) {
       entries[id] = entry;
     });
   }
 });
34279
 return entries;
34281
34282
};
34284
/**
* Gets an entry instance (either entry or headerEntry) by id.
*
* @param  {string} entryId
*
* @return {Object} entry instance
*/
PopupMenu.prototype._getEntry = function(entryId) {
34293
 var entry = this._current.entries[entryId];
34295
 if (!entry) {
   throw new Error('entry not found');
 }
34299
 return entry;
};
34302
PopupMenu.prototype._emit = function(eventName) {
 this._eventBus.fire('popupMenu.' + eventName);
};
34306
/**
* Creates the popup menu container.
*
* @return {Object} a DOM container
*/
PopupMenu.prototype._createContainer = function() {
 var container = domify('<div class="djs-popup">'),
     position = this._current.position,
     className = this._current.className;
34316
 assign$1(container, {
   position: 'absolute',
   left: position.x + 'px',
   top: position.y + 'px',
   visibility: 'hidden'
 });
34323
 classes(container).add(className);
34325
 return container;
};
34328
34329
/**
* Attaches the container to the DOM.
*
* @param {Object} container
* @param {Object} parent
*/
PopupMenu.prototype._attachContainer = function(container, parent, cursor) {
 var self = this;
34338
 // Event handler
 delegate.bind(container, '.entry' ,'click', function(event) {
   self.trigger(event);
 });
34343
 this._updateScale(container);
34345
 // Attach to DOM
 parent.appendChild(container);
34348
 if (cursor) {
   this._assureIsInbounds(container, cursor);
 }
};
34353
34354
/**
* Updates popup style.transform with respect to the config and zoom level.
*
* @method _updateScale
*
* @param {Object} container
*/
PopupMenu.prototype._updateScale = function(container) {
 var zoom = this._canvas.zoom();
34364
 var scaleConfig = this._config.scale,
     minScale,
     maxScale,
     scale = zoom;
34369
 if (scaleConfig !== true) {
34371
   if (scaleConfig === false) {
     minScale = 1;
     maxScale = 1;
   } else {
     minScale = scaleConfig.min;
     maxScale = scaleConfig.max;
   }
34379
   if (isDefined(minScale) && zoom < minScale) {
     scale = minScale;
   }
34383
   if (isDefined(maxScale) && zoom > maxScale) {
     scale = maxScale;
   }
34387
 }
34389
 setTransform(container, 'scale(' + scale + ')');
};
34392
34393
/**
* Make sure that the menu is always fully shown
*
* @method function
*
* @param  {Object} container
* @param  {Position} cursor {x, y}
*/
PopupMenu.prototype._assureIsInbounds = function(container, cursor) {
 var canvas = this._canvas,
     clientRect = canvas._container.getBoundingClientRect();
34405
 var containerX = container.offsetLeft,
     containerY = container.offsetTop,
     containerWidth = container.scrollWidth,
     containerHeight = container.scrollHeight,
     overAxis = {},
     left, top;
34412
 var cursorPosition = {
   x: cursor.x - clientRect.left,
   y: cursor.y - clientRect.top
 };
34417
 if (containerX + containerWidth > clientRect.width) {
   overAxis.x = true;
 }
34421
 if (containerY + containerHeight > clientRect.height) {
   overAxis.y = true;
 }
34425
 if (overAxis.x && overAxis.y) {
   left = cursorPosition.x - containerWidth + 'px';
   top = cursorPosition.y - containerHeight + 'px';
 } else if (overAxis.x) {
   left = cursorPosition.x - containerWidth + 'px';
   top = cursorPosition.y + 'px';
 } else if (overAxis.y && cursorPosition.y < containerHeight) {
   left = cursorPosition.x + 'px';
   top = 10 + 'px';
 } else if (overAxis.y) {
   left = cursorPosition.x + 'px';
   top = cursorPosition.y - containerHeight + 'px';
 }
34439
 assign$1(container, { left: left, top: top }, { visibility: 'visible', 'zIndex': 1000 });
};
34442
34443
/**
* Creates a list of entries and returns them as a DOM container.
*
* @param {Array<Object>} entries an array of entry objects
* @param {string} className the class name of the entry container
*
* @return {Object} a DOM container
*/
PopupMenu.prototype._createEntries = function(entries, className) {
34453
 var entriesContainer = domify('<div>'),
     self = this;
34456
 classes(entriesContainer).add(className);
34458
 forEach$2(entries, function(entry, id) {
   var entryContainer = self._createEntry(entry, id);
   entriesContainer.appendChild(entryContainer);
 });
34463
 return entriesContainer;
};
34466
34467
/**
* Creates a single entry and returns it as a DOM container.
*
* @param  {Object} entry
*
* @return {Object} a DOM container
*/
PopupMenu.prototype._createEntry = function(entry, id) {
34476
 var entryContainer = domify('<div>'),
     entryClasses = classes(entryContainer);
34479
 entryClasses.add('entry');
34481
 if (entry.className) {
   entry.className.split(' ').forEach(function(className) {
     entryClasses.add(className);
   });
 }
34487
 attr(entryContainer, DATA_REF, id);
34489
 if (entry.label) {
   var label = domify('<span>');
   label.textContent = entry.label;
   entryContainer.appendChild(label);
 }
34495
 if (entry.imageUrl) {
   entryContainer.appendChild(domify('<img src="' + entry.imageUrl + '" />'));
 }
34499
 if (entry.active === true) {
   entryClasses.add('active');
 }
34503
 if (entry.disabled === true) {
   entryClasses.add('disabled');
 }
34507
 if (entry.title) {
   entryContainer.title = entry.title;
 }
34511
 return entryContainer;
};
34514
34515
/**
* Set up listener to close popup automatically on certain events.
*/
PopupMenu.prototype._bindAutoClose = function() {
 this._eventBus.once(CLOSE_EVENTS, this.close, this);
};
34522
34523
/**
* Remove the auto-closing listener.
*/
PopupMenu.prototype._unbindAutoClose = function() {
 this._eventBus.off(CLOSE_EVENTS, this.close, this);
};
34530
34531
34532
// helpers /////////////////////////////
34534
function setTransform(element, transform) {
 element.style['transform-origin'] = 'top left';
34537
 [ '', '-ms-', '-webkit-' ].forEach(function(prefix) {
   element.style[prefix + 'transform'] = transform;
 });
}
34542
var PopupMenuModule$1 = {
 __init__: [ 'popupMenu' ],
 popupMenu: [ 'type', PopupMenu ]
};
34547
/**
* A clip board stub
*/
function Clipboard() {}
34552
34553
Clipboard.prototype.get = function() {
 return this._data;
};
34557
Clipboard.prototype.set = function(data) {
 this._data = data;
};
34561
Clipboard.prototype.clear = function() {
 var data = this._data;
34564
 delete this._data;
34566
 return data;
};
34569
Clipboard.prototype.isEmpty = function() {
 return !this._data;
};
34573
var ClipboardModule = {
 clipboard: [ 'type', Clipboard ]
};
34577
function Mouse(eventBus) {
 var self = this;
34580
 this._lastMoveEvent = null;
34582
 function setLastMoveEvent(mousemoveEvent) {
   self._lastMoveEvent = mousemoveEvent;
 }
34586
 eventBus.on('canvas.init', function(context) {
   var svg = self._svg = context.svg;
34589
   svg.addEventListener('mousemove', setLastMoveEvent);
 });
34592
 eventBus.on('canvas.destroy', function() {
   self._lastMouseEvent = null;
34595
   self._svg.removeEventListener('mousemove', setLastMoveEvent);
 });
}
34599
Mouse.$inject = [ 'eventBus' ];
34601
Mouse.prototype.getLastMoveEvent = function() {
 return this._lastMoveEvent || createMoveEvent(0, 0);
};
34605
// helpers //////////
34607
function createMoveEvent(x, y) {
 var event = document.createEvent('MouseEvent');
34610
 var screenX = x,
     screenY = y,
     clientX = x,
     clientY = y;
34615
 if (event.initMouseEvent) {
   event.initMouseEvent(
     'mousemove',
     true,
     true,
     window,
     0,
     screenX,
     screenY,
     clientX,
     clientY,
     false,
     false,
     false,
     false,
     0,
     null
   );
 }
34635
 return event;
}
34638
var MouseModule = {
 __init__: [ 'mouse' ],
 mouse: [ 'type', Mouse ]
};
34643
/**
* @typedef {Function} <copyPaste.canCopyElements> listener
*
* @param {Object} context
* @param {Array<djs.model.Base>} context.elements
*
* @returns {Array<djs.model.Base>|boolean} - Return elements to be copied or false to disallow
* copying.
*/
34653
/**
* @typedef {Function} <copyPaste.copyElement> listener
*
* @param {Object} context
* @param {Object} context.descriptor
* @param {djs.model.Base} context.element
* @param {Array<djs.model.Base>} context.elements
*/
34662
/**
* @typedef {Function} <copyPaste.createTree> listener
*
* @param {Object} context
* @param {djs.model.Base} context.element
* @param {Array<djs.model.Base>} context.children - Add children to be added to tree.
*/
34670
/**
* @typedef {Function} <copyPaste.elementsCopied> listener
*
* @param {Object} context
* @param {Object} context.elements
* @param {Object} context.tree
*/
34678
/**
* @typedef {Function} <copyPaste.pasteElement> listener
*
* @param {Object} context
* @param {Object} context.cache - Already created elements.
* @param {Object} context.descriptor
*/
34686
/**
* @typedef {Function} <copyPaste.pasteElements> listener
*
* @param {Object} context
* @param {Object} context.hints - Add hints before pasting.
*/
34693
/**
* Copy and paste elements.
*
* @param {Canvas} canvas
* @param {Create} create
* @param {Clipboard} clipboard
* @param {ElementFactory} elementFactory
* @param {EventBus} eventBus
* @param {Modeling} modeling
* @param {Mouse} mouse
* @param {Rules} rules
*/
function CopyPaste(
   canvas,
   create,
   clipboard,
   elementFactory,
   eventBus,
   modeling,
   mouse,
   rules
) {
34716
 this._canvas = canvas;
 this._create = create;
 this._clipboard = clipboard;
 this._elementFactory = elementFactory;
 this._eventBus = eventBus;
 this._modeling = modeling;
 this._mouse = mouse;
 this._rules = rules;
34725
 eventBus.on('copyPaste.copyElement', function(context) {
   var descriptor = context.descriptor,
       element = context.element,
       elements = context.elements;
34730
   // default priority (priority = 1)
   descriptor.priority = 1;
34733
   descriptor.id = element.id;
34735
   var parentCopied = find(elements, function(e) {
     return e === element.parent;
   });
34739
   // do NOT reference parent if parent wasn't copied
   if (parentCopied) {
     descriptor.parent = element.parent.id;
   }
34744
   // attachers (priority = 2)
   if (isAttacher$1(element)) {
     descriptor.priority = 2;
34748
     descriptor.host = element.host.id;
   }
34751
   // connections (priority = 3)
   if (isConnection$a(element)) {
     descriptor.priority = 3;
34755
     descriptor.source = element.source.id;
     descriptor.target = element.target.id;
34758
     descriptor.waypoints = copyWaypoints$1(element);
   }
34761
   // labels (priority = 4)
   if (isLabel$4(element)) {
     descriptor.priority = 4;
34765
     descriptor.labelTarget = element.labelTarget.id;
   }
34768
   forEach$2([ 'x', 'y', 'width', 'height' ], function(property) {
     if (isNumber(element[ property ])) {
       descriptor[ property ] = element[ property ];
     }
   });
34774
   descriptor.hidden = element.hidden;
   descriptor.collapsed = element.collapsed;
34777
 });
34779
 eventBus.on('copyPaste.pasteElements', function(context) {
   var hints = context.hints;
34782
   assign(hints, {
     createElementsBehavior: false
   });
 });
}
34788
CopyPaste.$inject = [
 'canvas',
 'create',
 'clipboard',
 'elementFactory',
 'eventBus',
 'modeling',
 'mouse',
 'rules'
];
34799
34800
/**
* Copy elements.
*
* @param {Array<djs.model.Base>} elements
*
* @returns {Object}
*/
CopyPaste.prototype.copy = function(elements) {
 var allowed,
     tree;
34811
 if (!isArray$4(elements)) {
   elements = elements ? [ elements ] : [];
 }
34815
 allowed = this._eventBus.fire('copyPaste.canCopyElements', {
   elements: elements
 });
34819
 if (allowed === false) {
   tree = {};
 } else {
   tree = this.createTree(isArray$4(allowed) ? allowed : elements);
 }
34825
 // we set an empty tree, selection of elements
 // to copy was empty.
 this._clipboard.set(tree);
34829
 this._eventBus.fire('copyPaste.elementsCopied', {
   elements: elements,
   tree: tree
 });
34834
 return tree;
};
34837
/**
* Paste elements.
*
* @param {Object} [context]
* @param {djs.model.base} [context.element] - Parent.
* @param {Point} [context.point] - Position.
* @param {Object} [context.hints] - Hints.
*/
CopyPaste.prototype.paste = function(context) {
 var tree = this._clipboard.get();
34848
 if (this._clipboard.isEmpty()) {
   return;
 }
34852
 var hints = context && context.hints || {};
34854
 this._eventBus.fire('copyPaste.pasteElements', {
   hints: hints
 });
34858
 var elements = this._createElements(tree);
34860
 // paste directly
 if (context && context.element && context.point) {
   return this._paste(elements, context.element, context.point, hints);
 }
34865
 this._create.start(this._mouse.getLastMoveEvent(), elements, {
   hints: hints || {}
 });
};
34870
/**
* Paste elements directly.
*
* @param {Array<djs.model.Base>} elements
* @param {djs.model.base} target
* @param {Point} position
* @param {Object} [hints]
*/
CopyPaste.prototype._paste = function(elements, target, position, hints) {
34880
 // make sure each element has x and y
 forEach$2(elements, function(element) {
   if (!isNumber(element.x)) {
     element.x = 0;
   }
34886
   if (!isNumber(element.y)) {
     element.y = 0;
   }
 });
34891
 var bbox = getBBox(elements);
34893
 // center elements around cursor
 forEach$2(elements, function(element) {
   if (isConnection$a(element)) {
     element.waypoints = map(element.waypoints, function(waypoint) {
       return {
         x: waypoint.x - bbox.x - bbox.width / 2,
         y: waypoint.y - bbox.y - bbox.height / 2
       };
     });
   }
34904
   assign(element, {
     x: element.x - bbox.x - bbox.width / 2,
     y: element.y - bbox.y - bbox.height / 2
   });
 });
34910
 return this._modeling.createElements(elements, position, target, assign({}, hints));
};
34913
/**
* Create elements from tree.
*/
CopyPaste.prototype._createElements = function(tree) {
 var self = this;
34919
 var eventBus = this._eventBus;
34921
 var cache = {};
34923
 var elements = [];
34925
 forEach$2(tree, function(branch, depth) {
34927
   // sort by priority
   branch = sortBy(branch, 'priority');
34930
   forEach$2(branch, function(descriptor) {
34932
     // remove priority
     var attrs = assign({}, omit(descriptor, [ 'priority' ]));
34935
     if (cache[ descriptor.parent ]) {
       attrs.parent = cache[ descriptor.parent ];
     } else {
       delete attrs.parent;
     }
34941
     eventBus.fire('copyPaste.pasteElement', {
       cache: cache,
       descriptor: attrs
     });
34946
     var element;
34948
     if (isConnection$a(attrs)) {
       attrs.source = cache[ descriptor.source ];
       attrs.target = cache[ descriptor.target ];
34952
       element = cache[ descriptor.id ] = self.createConnection(attrs);
34954
       elements.push(element);
34956
       return;
     }
34959
     if (isLabel$4(attrs)) {
       attrs.labelTarget = cache[ attrs.labelTarget ];
34962
       element = cache[ descriptor.id ] = self.createLabel(attrs);
34964
       elements.push(element);
34966
       return;
     }
34969
     if (attrs.host) {
       attrs.host = cache[ attrs.host ];
     }
34973
     element = cache[ descriptor.id ] = self.createShape(attrs);
34975
     elements.push(element);
   });
34978
 });
34980
 return elements;
};
34983
CopyPaste.prototype.createConnection = function(attrs) {
 var connection = this._elementFactory.createConnection(omit(attrs, [ 'id' ]));
34986
 return connection;
};
34989
CopyPaste.prototype.createLabel = function(attrs) {
 var label = this._elementFactory.createLabel(omit(attrs, [ 'id' ]));
34992
 return label;
};
34995
CopyPaste.prototype.createShape = function(attrs) {
 var shape = this._elementFactory.createShape(omit(attrs, [ 'id' ]));
34998
 return shape;
};
35001
/**
* Check wether element has relations to other elements e.g. attachers, labels and connections.
*
* @param  {Object} element
* @param  {Array<djs.model.Base>} elements
*
* @returns {boolean}
*/
CopyPaste.prototype.hasRelations = function(element, elements) {
 var labelTarget,
     source,
     target;
35014
 if (isConnection$a(element)) {
   source = find(elements, matchPattern({ id: element.source.id }));
   target = find(elements, matchPattern({ id: element.target.id }));
35018
   if (!source || !target) {
     return false;
   }
 }
35023
 if (isLabel$4(element)) {
   labelTarget = find(elements, matchPattern({ id: element.labelTarget.id }));
35026
   if (!labelTarget) {
     return false;
   }
 }
35031
 return true;
};
35034
/**
* Create a tree-like structure from elements.
*
* @example
* tree: {
 *  0: [
 *    { id: 'Shape_1', priority: 1, ... },
 *    { id: 'Shape_2', priority: 1, ... },
 *    { id: 'Connection_1', source: 'Shape_1', target: 'Shape_2', priority: 3, ... },
 *    ...
 *  ],
 *  1: [
 *    { id: 'Shape_3', parent: 'Shape1', priority: 1, ... },
 *    ...
 *  ]
 * };
 *
 * @param  {Array<djs.model.base>} elements
 *
 * @return {Object}
 */
CopyPaste.prototype.createTree = function(elements) {
 var rules = this._rules,
     self = this;
35059
 var tree = {},
     elementsData = [];
35062
 var parents = getParents$1(elements);
35064
 function canCopy(element, elements) {
   return rules.allowed('element.copy', {
     element: element,
     elements: elements
   });
 }
35071
 function addElementData(element, depth) {
35073
   // (1) check wether element has already been added
   var foundElementData = find(elementsData, function(elementsData) {
     return element === elementsData.element;
   });
35078
   // (2) add element if not already added
   if (!foundElementData) {
     elementsData.push({
       element: element,
       depth: depth
     });
35085
     return;
   }
35088
   // (3) update depth
   if (foundElementData.depth < depth) {
     elementsData = removeElementData(foundElementData, elementsData);
35092
     elementsData.push({
       element: foundElementData.element,
       depth: depth
     });
   }
 }
35099
 function removeElementData(elementData, elementsData) {
   var index = elementsData.indexOf(elementData);
35102
   if (index !== -1) {
     elementsData.splice(index, 1);
   }
35106
   return elementsData;
 }
35109
 // (1) add elements
 eachElement(parents, function(element, _index, depth) {
35112
   // do NOT add external labels directly
   if (isLabel$4(element)) {
     return;
   }
35117
   // always copy external labels
   forEach$2(element.labels, function(label) {
     addElementData(label, depth);
   });
35122
   function addRelatedElements(elements) {
     elements && elements.length && forEach$2(elements, function(element) {
35125
       // add external labels
       forEach$2(element.labels, function(label) {
         addElementData(label, depth);
       });
35130
       addElementData(element, depth);
     });
   }
35134
   forEach$2([ element.attachers, element.incoming, element.outgoing ], addRelatedElements);
35136
   addElementData(element, depth);
35138
   var children = [];
35140
   if (element.children) {
     children = element.children.slice();
   }
35144
   // allow others to add children to tree
   self._eventBus.fire('copyPaste.createTree', {
     element: element,
     children: children
   });
35150
   return children;
 });
35153
 elements = map(elementsData, function(elementData) {
   return elementData.element;
 });
35157
 // (2) copy elements
 elementsData = map(elementsData, function(elementData) {
   elementData.descriptor = {};
35161
   self._eventBus.fire('copyPaste.copyElement', {
     descriptor: elementData.descriptor,
     element: elementData.element,
     elements: elements
   });
35167
   return elementData;
 });
35170
 // (3) sort elements by priority
 elementsData = sortBy(elementsData, function(elementData) {
   return elementData.descriptor.priority;
 });
35175
 elements = map(elementsData, function(elementData) {
   return elementData.element;
 });
35179
 // (4) create tree
 forEach$2(elementsData, function(elementData) {
   var depth = elementData.depth;
35183
   if (!self.hasRelations(elementData.element, elements)) {
     removeElement(elementData.element, elements);
35186
     return;
   }
35189
   if (!canCopy(elementData.element, elements)) {
     removeElement(elementData.element, elements);
35192
     return;
   }
35195
   if (!tree[depth]) {
     tree[depth] = [];
   }
35199
   tree[depth].push(elementData.descriptor);
 });
35202
 return tree;
};
35205
// helpers //////////
35207
function isAttacher$1(element) {
 return !!element.host;
}
35211
function isConnection$a(element) {
 return !!element.waypoints;
}
35215
function isLabel$4(element) {
 return !!element.labelTarget;
}
35219
function copyWaypoints$1(element) {
 return map(element.waypoints, function(waypoint) {
35222
   waypoint = copyWaypoint$1(waypoint);
35224
   if (waypoint.original) {
     waypoint.original = copyWaypoint$1(waypoint.original);
   }
35228
   return waypoint;
 });
}
35232
function copyWaypoint$1(waypoint) {
 return assign({}, waypoint);
}
35236
function removeElement(element, elements) {
 var index = elements.indexOf(element);
35239
 if (index === -1) {
   return elements;
 }
35243
 return elements.splice(index, 1);
}
35246
var CopyPasteModule$1 = {
 __depends__: [
   ClipboardModule,
   CreateModule,
   MouseModule,
   RulesModule$1
 ],
 __init__: [ 'copyPaste' ],
 copyPaste: [ 'type', CopyPaste ]
};
35257
function copyProperties$1(source, target, properties) {
 if (!isArray$4(properties)) {
   properties = [ properties ];
 }
35262
 forEach$2(properties, function(property) {
   if (!isUndefined$3(source[property])) {
     target[property] = source[property];
   }
 });
}
35269
function removeProperties(element, properties) {
 if (!isArray$4(properties)) {
   properties = [ properties ];
 }
35274
 forEach$2(properties, function(property) {
   if (element[property]) {
     delete element[property];
   }
 });
}
35281
var LOW_PRIORITY$g = 750;
35283
35284
function BpmnCopyPaste(bpmnFactory, eventBus, moddleCopy) {
35286
 eventBus.on('copyPaste.copyElement', LOW_PRIORITY$g, function(context) {
   var descriptor = context.descriptor,
       element = context.element;
35290
   var businessObject = descriptor.oldBusinessObject = getBusinessObject(element);
   var di = descriptor.oldDi = getDi(element);
35293
   descriptor.type = element.type;
35295
   copyProperties$1(businessObject, descriptor, 'name');
35297
   copyProperties$1(di, descriptor, 'isExpanded');
35299
   if (isLabel$3(descriptor)) {
     return descriptor;
   }
35303
   // default sequence flow
   if (businessObject.default) {
     descriptor.default = businessObject.default.id;
   }
 });
35309
 eventBus.on('moddleCopy.canCopyProperty', function(context) {
   var parent = context.parent,
       property = context.property,
       propertyName = context.propertyName,
       bpmnProcess;
35315
   if (
     propertyName === 'processRef' &&
     is$1(parent, 'bpmn:Participant') &&
     is$1(property, 'bpmn:Process')
   ) {
     bpmnProcess = bpmnFactory.create('bpmn:Process');
35322
     // return copy of process
     return moddleCopy.copyElement(property, bpmnProcess);
   }
 });
35327
 var references;
35329
 function resolveReferences(descriptor, cache) {
   var businessObject = getBusinessObject(descriptor);
35332
   // default sequence flows
   if (descriptor.default) {
35335
     // relationship cannot be resolved immediately
     references[ descriptor.default ] = {
       element: businessObject,
       property: 'default'
     };
   }
35342
   // boundary events
   if (descriptor.host) {
35345
     // relationship can be resolved immediately
     getBusinessObject(descriptor).attachedToRef = getBusinessObject(cache[ descriptor.host ]);
   }
35349
   references = omit(references, reduce(references, function(array, reference, key) {
     var element = reference.element,
         property = reference.property;
35353
     if (key === descriptor.id) {
       element[ property ] = businessObject;
35356
       array.push(descriptor.id);
     }
35359
     return array;
   }, []));
 }
35363
 eventBus.on('copyPaste.pasteElements', function() {
   references = {};
 });
35367
 eventBus.on('copyPaste.pasteElement', function(context) {
   var cache = context.cache,
       descriptor = context.descriptor,
       oldBusinessObject = descriptor.oldBusinessObject,
       oldDi = descriptor.oldDi,
       newBusinessObject, newDi;
35374
   // do NOT copy business object if external label
   if (isLabel$3(descriptor)) {
     descriptor.businessObject = getBusinessObject(cache[ descriptor.labelTarget ]);
     descriptor.di = getDi(cache[ descriptor.labelTarget ]);
35379
     return;
   }
35382
   newBusinessObject = bpmnFactory.create(oldBusinessObject.$type);
35384
   descriptor.businessObject = moddleCopy.copyElement(
     oldBusinessObject,
     newBusinessObject
   );
35389
   newDi = bpmnFactory.create(oldDi.$type);
   newDi.bpmnElement = newBusinessObject;
35392
   descriptor.di = moddleCopy.copyElement(
     oldDi,
     newDi
   );
35397
   // resolve references e.g. default sequence flow
   resolveReferences(descriptor, cache);
35400
   copyProperties$1(descriptor, newBusinessObject, [
     'isExpanded',
     'name'
   ]);
35405
   removeProperties(descriptor, 'oldBusinessObject');
 });
35408
}
35410
35411
BpmnCopyPaste.$inject = [
 'bpmnFactory',
 'eventBus',
 'moddleCopy'
];
35417
// helpers //////////
35419
function isLabel$3(element) {
 return !!element.labelTarget;
}
35423
var DISALLOWED_PROPERTIES = [
 'artifacts',
 'dataInputAssociations',
 'dataOutputAssociations',
 'default',
 'flowElements',
 'lanes',
 'incoming',
 'outgoing'
];
35434
/**
* @typedef {Function} <moddleCopy.canCopyProperties> listener
*
* @param {Object} context
* @param {Array<string>} context.propertyNames
* @param {ModdleElement} context.sourceElement
* @param {ModdleElement} context.targetElement
*
* @returns {Array<string>|boolean} - Return properties to be copied or false to disallow
* copying.
*/
35446
/**
* @typedef {Function} <moddleCopy.canCopyProperty> listener
*
* @param {Object} context
* @param {ModdleElement} context.parent
* @param {*} context.property
* @param {string} context.propertyName
*
* @returns {*|boolean} - Return copied property or false to disallow
* copying.
*/
35458
/**
* @typedef {Function} <moddleCopy.canSetCopiedProperty> listener
*
* @param {Object} context
* @param {ModdleElement} context.parent
* @param {*} context.property
* @param {string} context.propertyName
*
* @returns {boolean} - Return false to disallow
* setting copied property.
*/
35470
/**
* Utility for copying model properties from source element to target element.
*
* @param {EventBus} eventBus
* @param {BpmnFactory} bpmnFactory
* @param {BpmnModdle} moddle
*/
function ModdleCopy(eventBus, bpmnFactory, moddle) {
 this._bpmnFactory = bpmnFactory;
 this._eventBus = eventBus;
 this._moddle = moddle;
35482
 // copy extension elements last
 eventBus.on('moddleCopy.canCopyProperties', function(context) {
   var propertyNames = context.propertyNames;
35486
   if (!propertyNames || !propertyNames.length) {
     return;
   }
35490
   return sortBy(propertyNames, function(propertyName) {
     return propertyName === 'extensionElements';
   });
 });
35495
 // default check whether property can be copied
 eventBus.on('moddleCopy.canCopyProperty', function(context) {
   var parent = context.parent,
       parentDescriptor = isObject(parent) && parent.$descriptor,
       propertyName = context.propertyName;
35501
   if (propertyName && DISALLOWED_PROPERTIES.indexOf(propertyName) !== -1) {
35503
     // disallow copying property
     return false;
   }
35507
   if (propertyName &&
     parentDescriptor &&
     !find(parentDescriptor.properties, matchPattern({ name: propertyName }))) {
35511
     // disallow copying property
     return false;
   }
 });
35516
 // do NOT allow to copy empty extension elements
 eventBus.on('moddleCopy.canSetCopiedProperty', function(context) {
   var property = context.property;
35520
   if (is(property, 'bpmn:ExtensionElements') && (!property.values || !property.values.length)) {
35522
     // disallow setting copied property
     return false;
   }
 });
}
35528
ModdleCopy.$inject = [
 'eventBus',
 'bpmnFactory',
 'moddle'
];
35534
/**
* Copy model properties of source element to target element.
*
* @param {ModdleElement} sourceElement
* @param {ModdleElement} targetElement
* @param {Array<string>} [propertyNames]
*
* @param {ModdleElement}
*/
ModdleCopy.prototype.copyElement = function(sourceElement, targetElement, propertyNames) {
 var self = this;
35546
 if (propertyNames && !isArray$4(propertyNames)) {
   propertyNames = [ propertyNames ];
 }
35550
 propertyNames = propertyNames || getPropertyNames(sourceElement.$descriptor);
35552
 var canCopyProperties = this._eventBus.fire('moddleCopy.canCopyProperties', {
   propertyNames: propertyNames,
   sourceElement: sourceElement,
   targetElement: targetElement
 });
35558
 if (canCopyProperties === false) {
   return targetElement;
 }
35562
 if (isArray$4(canCopyProperties)) {
   propertyNames = canCopyProperties;
 }
35566
 // copy properties
 forEach$2(propertyNames, function(propertyName) {
   var sourceProperty;
35570
   if (has$2(sourceElement, propertyName)) {
     sourceProperty = sourceElement.get(propertyName);
   }
35574
   var copiedProperty = self.copyProperty(sourceProperty, targetElement, propertyName);
35576
   var canSetProperty = self._eventBus.fire('moddleCopy.canSetCopiedProperty', {
     parent: targetElement,
     property: copiedProperty,
     propertyName: propertyName
   });
35582
   if (canSetProperty === false) {
     return;
   }
35586
   if (isDefined(copiedProperty)) {
     targetElement.set(propertyName, copiedProperty);
   }
 });
35591
 return targetElement;
};
35594
/**
* Copy model property.
*
* @param {*} property
* @param {ModdleElement} parent
* @param {string} propertyName
*
* @returns {*}
*/
ModdleCopy.prototype.copyProperty = function(property, parent, propertyName) {
 var self = this;
35606
 // allow others to copy property
 var copiedProperty = this._eventBus.fire('moddleCopy.canCopyProperty', {
   parent: parent,
   property: property,
   propertyName: propertyName
 });
35613
 // return if copying is NOT allowed
 if (copiedProperty === false) {
   return;
 }
35618
 if (copiedProperty) {
   if (isObject(copiedProperty) && copiedProperty.$type && !copiedProperty.$parent) {
     copiedProperty.$parent = parent;
   }
35623
   return copiedProperty;
 }
35626
 var propertyDescriptor = this._moddle.getPropertyDescriptor(parent, propertyName);
35628
 // do NOT copy references
 if (propertyDescriptor.isReference) {
   return;
 }
35633
 // copy id
 if (propertyDescriptor.isId) {
   return this._copyId(property, parent);
 }
35638
 // copy arrays
 if (isArray$4(property)) {
   return reduce(property, function(childProperties, childProperty) {
35642
     // recursion
     copiedProperty = self.copyProperty(childProperty, parent, propertyName);
35645
     // copying might NOT be allowed
     if (copiedProperty) {
       copiedProperty.$parent = parent;
35649
       return childProperties.concat(copiedProperty);
     }
35652
     return childProperties;
   }, []);
 }
35656
 // copy model elements
 if (isObject(property) && property.$type) {
   if (this._moddle.getElementDescriptor(property).isGeneric) {
     return;
   }
35662
   copiedProperty = self._bpmnFactory.create(property.$type);
35664
   copiedProperty.$parent = parent;
35666
   // recursion
   copiedProperty = self.copyElement(property, copiedProperty);
35669
   return copiedProperty;
 }
35672
 // copy primitive properties
 return property;
};
35676
ModdleCopy.prototype._copyId = function(id, element) {
35678
 // disallow if already taken
 if (this._moddle.ids.assigned(id)) {
   return;
 } else {
35683
   this._moddle.ids.claim(id, element);
   return id;
 }
};
35688
// helpers //////////
35690
function getPropertyNames(descriptor, keepDefaultProperties) {
 return reduce(descriptor.properties, function(properties, property) {
35693
   if (keepDefaultProperties && property.default) {
     return properties;
   }
35697
   return properties.concat(property.name);
 }, []);
}
35701
function is(element, type) {
 return element && (typeof element.$instanceOf === 'function') && element.$instanceOf(type);
}
35705
var CopyPasteModule = {
 __depends__: [
   CopyPasteModule$1
 ],
 __init__: [ 'bpmnCopyPaste', 'moddleCopy' ],
 bpmnCopyPaste: [ 'type', BpmnCopyPaste ],
 moddleCopy: [ 'type', ModdleCopy ]
};
35714
var round$5 = Math.round;
35716
/**
* Service that allow replacing of elements.
*/
function Replace(modeling) {
35721
 this._modeling = modeling;
}
35724
Replace.$inject = [ 'modeling' ];
35726
/**
* @param {Element} oldElement - Element to be replaced
* @param {Object}  newElementData - Containing information about the new element,
*                                   for example the new bounds and type.
* @param {Object}  options - Custom options that will be attached to the context. It can be used to inject data
*                            that is needed in the command chain. For example it could be used in
*                            eventbus.on('commandStack.shape.replace.postExecute') to change shape attributes after
*                            shape creation.
*/
Replace.prototype.replaceElement = function(oldElement, newElementData, options) {
35737
 if (oldElement.waypoints) {
35739
   // TODO(nikku): we do not replace connections, yet
   return null;
 }
35743
 var modeling = this._modeling;
35745
 var width = newElementData.width || oldElement.width,
     height = newElementData.height || oldElement.height,
     x = newElementData.x || oldElement.x,
     y = newElementData.y || oldElement.y,
     centerX = round$5(x + width / 2),
     centerY = round$5(y + height / 2);
35752
 // modeling API requires center coordinates,
 // account for that when handling shape bounds
35755
 return modeling.replaceShape(
   oldElement,
   assign(
     {},
     newElementData,
     {
       x: centerX,
       y: centerY,
       width: width,
       height: height
     }
   ),
   options
 );
};
35771
var ReplaceModule$1 = {
 __init__: [ 'replace' ],
 replace: [ 'type', Replace ]
};
35776
function copyProperties(source, target, properties) {
 if (!isArray$4(properties)) {
   properties = [ properties ];
 }
35781
 forEach$2(properties, function(property) {
   if (!isUndefined$3(source[property])) {
     target[property] = source[property];
   }
 });
}
35788
35789
var CUSTOM_PROPERTIES = [
 'cancelActivity',
 'instantiate',
 'eventGatewayType',
 'triggeredByEvent',
 'isInterrupting'
];
35797
/**
* Check if element should be collapsed or expanded.
*/
function shouldToggleCollapsed(element, targetElement) {
35802
 var oldCollapsed = (
   element && has$2(element, 'collapsed') ? element.collapsed : !isExpanded(element)
 );
35806
 var targetCollapsed;
35808
 if (targetElement && (has$2(targetElement, 'collapsed') || has$2(targetElement, 'isExpanded'))) {
35810
   // property is explicitly set so use it
   targetCollapsed = (
     has$2(targetElement, 'collapsed') ? targetElement.collapsed : !targetElement.isExpanded
   );
 } else {
35816
   // keep old state
   targetCollapsed = oldCollapsed;
 }
35820
 if (oldCollapsed !== targetCollapsed) {
   return true;
 }
35824
 return false;
}
35827
35828
/**
* This module takes care of replacing BPMN elements
*/
function BpmnReplace(
   bpmnFactory,
   elementFactory,
   moddleCopy,
   modeling,
   replace,
   rules,
   selection
) {
35841
 /**
  * Prepares a new business object for the replacement element
  * and triggers the replace operation.
  *
  * @param  {djs.model.Base} element
  * @param  {Object} target
  * @param  {Object} [hints]
  *
  * @return {djs.model.Base} the newly created element
  */
 function replaceElement(element, target, hints) {
35853
   hints = hints || {};
35855
   var type = target.type,
       oldBusinessObject = element.businessObject;
35858
   if (isSubProcess(oldBusinessObject) && type === 'bpmn:SubProcess') {
     if (shouldToggleCollapsed(element, target)) {
35861
       // expanding or collapsing process
       modeling.toggleCollapse(element);
35864
       return element;
     }
   }
35868
   var newBusinessObject = bpmnFactory.create(type);
35870
   var newElement = {
     type: type,
     businessObject: newBusinessObject,
   };
35875
   newElement.di = {};
35877
   // colors will be set to DI
   copyProperties(element.di, newElement.di, [
     'fill',
     'stroke',
     'background-color',
     'border-color',
     'color'
   ]);
35886
   var elementProps = getPropertyNames(oldBusinessObject.$descriptor),
       newElementProps = getPropertyNames(newBusinessObject.$descriptor, true),
       copyProps = intersection(elementProps, newElementProps);
35890
   // initialize special properties defined in target definition
   assign(newBusinessObject, pick(target, CUSTOM_PROPERTIES));
35893
   var properties = filter(copyProps, function(propertyName) {
35895
     // copying event definitions, unless we replace
     if (propertyName === 'eventDefinitions') {
       return hasEventDefinition$1(element, target.eventDefinitionType);
     }
35900
     // retain loop characteristics if the target element
     // is not an event sub process
     if (propertyName === 'loopCharacteristics') {
       return !isEventSubProcess(newBusinessObject);
     }
35906
     // so the applied properties from 'target' don't get lost
     if (has$2(newBusinessObject, propertyName)) {
       return false;
     }
35911
     if (propertyName === 'processRef' && target.isExpanded === false) {
       return false;
     }
35915
     if (propertyName === 'triggeredByEvent') {
       return false;
     }
35919
     return true;
   });
35922
   newBusinessObject = moddleCopy.copyElement(
     oldBusinessObject,
     newBusinessObject,
     properties
   );
35928
   // initialize custom BPMN extensions
   if (target.eventDefinitionType) {
35931
     // only initialize with new eventDefinition
     // if we did not set an event definition yet,
     // i.e. because we copied it
     if (!hasEventDefinition$1(newBusinessObject, target.eventDefinitionType)) {
       newElement.eventDefinitionType = target.eventDefinitionType;
       newElement.eventDefinitionAttrs = target.eventDefinitionAttrs;
     }
   }
35940
   if (is$1(oldBusinessObject, 'bpmn:Activity')) {
35942
     if (isSubProcess(oldBusinessObject)) {
35944
       // no toggeling, so keep old state
       newElement.isExpanded = isExpanded(element);
     }
35948
     // else if property is explicitly set, use it
     else if (target && has$2(target, 'isExpanded')) {
       newElement.isExpanded = target.isExpanded;
     }
35953
     // TODO: need also to respect min/max Size
     // copy size, from an expanded subprocess to an expanded alternative subprocess
     // except bpmn:Task, because Task is always expanded
     if ((isExpanded(element) && !is$1(oldBusinessObject, 'bpmn:Task')) && newElement.isExpanded) {
       newElement.width = element.width;
       newElement.height = element.height;
     }
   }
35962
   // remove children if not expanding sub process
   if (isSubProcess(oldBusinessObject) && !isSubProcess(newBusinessObject)) {
     hints.moveChildren = false;
   }
35967
   // transform collapsed/expanded pools
   if (is$1(oldBusinessObject, 'bpmn:Participant')) {
35970
     // create expanded pool
     if (target.isExpanded === true) {
       newBusinessObject.processRef = bpmnFactory.create('bpmn:Process');
     } else {
35975
       // remove children when transforming to collapsed pool
       hints.moveChildren = false;
     }
35979
     // apply same width and default height
     newElement.width = element.width;
     newElement.height = elementFactory.getDefaultSize(newElement).height;
   }
35984
   if (!rules.allowed('shape.resize', { shape: newBusinessObject })) {
     newElement.height = elementFactory.getDefaultSize(newElement).height;
     newElement.width = elementFactory.getDefaultSize(newElement).width;
   }
35989
   newBusinessObject.name = oldBusinessObject.name;
35991
   // retain default flow's reference between inclusive <-> exclusive gateways and activities
   if (
     isAny(oldBusinessObject, [
       'bpmn:ExclusiveGateway',
       'bpmn:InclusiveGateway',
       'bpmn:Activity'
     ]) &&
     isAny(newBusinessObject, [
       'bpmn:ExclusiveGateway',
       'bpmn:InclusiveGateway',
       'bpmn:Activity'
     ])
   ) {
     newBusinessObject.default = oldBusinessObject.default;
   }
36007
   if (
     target.host &&
     !is$1(oldBusinessObject, 'bpmn:BoundaryEvent') &&
     is$1(newBusinessObject, 'bpmn:BoundaryEvent')
   ) {
     newElement.host = target.host;
   }
36015
   // The DataStoreReference element is 14px wider than the DataObjectReference element
   // This ensures that they stay centered on the x axis when replaced
   if (
     newElement.type === 'bpmn:DataStoreReference' ||
     newElement.type === 'bpmn:DataObjectReference'
   ) {
     newElement.x = element.x + (element.width - newElement.width) / 2;
   }
36024
36025
   newElement = replace.replaceElement(element, newElement, hints);
36027
   if (hints.select !== false) {
     selection.select(newElement);
   }
36031
   return newElement;
 }
36034
 this.replaceElement = replaceElement;
}
36037
BpmnReplace.$inject = [
 'bpmnFactory',
 'elementFactory',
 'moddleCopy',
 'modeling',
 'replace',
 'rules',
 'selection'
];
36047
36048
function isSubProcess(bo) {
 return is$1(bo, 'bpmn:SubProcess');
}
36052
function hasEventDefinition$1(element, type) {
36054
 var bo = getBusinessObject(element);
36056
 return type && bo.get('eventDefinitions').some(function(definition) {
   return is$1(definition, type);
 });
}
36061
/**
* Compute intersection between two arrays.
*/
function intersection(a1, a2) {
 return a1.filter(function(el) {
   return a2.indexOf(el) !== -1;
 });
}
36070
var ReplaceModule = {
 __depends__: [
   CopyPasteModule,
   ReplaceModule$1,
   SelectionModule
 ],
 bpmnReplace: [ 'type', BpmnReplace ]
};
36079
/**
* Returns true, if an element is from a different type
* than a target definition. Takes into account the type,
* event definition type and triggeredByEvent property.
*
* @param {djs.model.Base} element
*
* @return {boolean}
*/
function isDifferentType(element) {
36090
 return function(entry) {
   var target = entry.target;
36093
   var businessObject = getBusinessObject(element),
       eventDefinition = businessObject.eventDefinitions && businessObject.eventDefinitions[0];
36096
   var isTypeEqual = businessObject.$type === target.type;
36098
   var isEventDefinitionEqual = (
     (eventDefinition && eventDefinition.$type) === target.eventDefinitionType
   );
36102
   var isTriggeredByEventEqual = (
     businessObject.triggeredByEvent === target.triggeredByEvent
   );
36106
   var isExpandedEqual = (
     target.isExpanded === undefined ||
     target.isExpanded === isExpanded(element)
   );
36111
   return !isTypeEqual || !isEventDefinitionEqual || !isTriggeredByEventEqual || !isExpandedEqual;
 };
}
36115
var START_EVENT = [
 {
   label: 'Start Event',
   actionName: 'replace-with-none-start',
   className: 'bpmn-icon-start-event-none',
   target: {
     type: 'bpmn:StartEvent'
   }
 },
 {
   label: 'Intermediate Throw Event',
   actionName: 'replace-with-none-intermediate-throwing',
   className: 'bpmn-icon-intermediate-event-none',
   target: {
     type: 'bpmn:IntermediateThrowEvent'
   }
 },
 {
   label: 'End Event',
   actionName: 'replace-with-none-end',
   className: 'bpmn-icon-end-event-none',
   target: {
     type: 'bpmn:EndEvent'
   }
 },
 {
   label: 'Message Start Event',
   actionName: 'replace-with-message-start',
   className: 'bpmn-icon-start-event-message',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition'
   }
 },
 {
   label: 'Timer Start Event',
   actionName: 'replace-with-timer-start',
   className: 'bpmn-icon-start-event-timer',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:TimerEventDefinition'
   }
 },
 {
   label: 'Conditional Start Event',
   actionName: 'replace-with-conditional-start',
   className: 'bpmn-icon-start-event-condition',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:ConditionalEventDefinition'
   }
 },
 {
   label: 'Signal Start Event',
   actionName: 'replace-with-signal-start',
   className: 'bpmn-icon-start-event-signal',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition'
   }
 }
];
36178
var START_EVENT_SUB_PROCESS = [
 {
   label: 'Start Event',
   actionName: 'replace-with-none-start',
   className: 'bpmn-icon-start-event-none',
   target: {
     type: 'bpmn:StartEvent'
   }
 },
 {
   label: 'Intermediate Throw Event',
   actionName: 'replace-with-none-intermediate-throwing',
   className: 'bpmn-icon-intermediate-event-none',
   target: {
     type: 'bpmn:IntermediateThrowEvent'
   }
 },
 {
   label: 'End Event',
   actionName: 'replace-with-none-end',
   className: 'bpmn-icon-end-event-none',
   target: {
     type: 'bpmn:EndEvent'
   }
 }
];
36205
var INTERMEDIATE_EVENT = [
 {
   label: 'Start Event',
   actionName: 'replace-with-none-start',
   className: 'bpmn-icon-start-event-none',
   target: {
     type: 'bpmn:StartEvent'
   }
 },
 {
   label: 'Intermediate Throw Event',
   actionName: 'replace-with-none-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-none',
   target: {
     type: 'bpmn:IntermediateThrowEvent'
   }
 },
 {
   label: 'End Event',
   actionName: 'replace-with-none-end',
   className: 'bpmn-icon-end-event-none',
   target: {
     type: 'bpmn:EndEvent'
   }
 },
 {
   label: 'Message Intermediate Catch Event',
   actionName: 'replace-with-message-intermediate-catch',
   className: 'bpmn-icon-intermediate-event-catch-message',
   target: {
     type: 'bpmn:IntermediateCatchEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition'
   }
 },
 {
   label: 'Message Intermediate Throw Event',
   actionName: 'replace-with-message-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-throw-message',
   target: {
     type: 'bpmn:IntermediateThrowEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition'
   }
 },
 {
   label: 'Timer Intermediate Catch Event',
   actionName: 'replace-with-timer-intermediate-catch',
   className: 'bpmn-icon-intermediate-event-catch-timer',
   target: {
     type: 'bpmn:IntermediateCatchEvent',
     eventDefinitionType: 'bpmn:TimerEventDefinition'
   }
 },
 {
   label: 'Escalation Intermediate Throw Event',
   actionName: 'replace-with-escalation-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-throw-escalation',
   target: {
     type: 'bpmn:IntermediateThrowEvent',
     eventDefinitionType: 'bpmn:EscalationEventDefinition'
   }
 },
 {
   label: 'Conditional Intermediate Catch Event',
   actionName: 'replace-with-conditional-intermediate-catch',
   className: 'bpmn-icon-intermediate-event-catch-condition',
   target: {
     type: 'bpmn:IntermediateCatchEvent',
     eventDefinitionType: 'bpmn:ConditionalEventDefinition'
   }
 },
 {
   label: 'Link Intermediate Catch Event',
   actionName: 'replace-with-link-intermediate-catch',
   className: 'bpmn-icon-intermediate-event-catch-link',
   target: {
     type: 'bpmn:IntermediateCatchEvent',
     eventDefinitionType: 'bpmn:LinkEventDefinition',
     eventDefinitionAttrs: {
       name: ''
     }
   }
 },
 {
   label: 'Link Intermediate Throw Event',
   actionName: 'replace-with-link-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-throw-link',
   target: {
     type: 'bpmn:IntermediateThrowEvent',
     eventDefinitionType: 'bpmn:LinkEventDefinition',
     eventDefinitionAttrs: {
       name: ''
     }
   }
 },
 {
   label: 'Compensation Intermediate Throw Event',
   actionName: 'replace-with-compensation-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-throw-compensation',
   target: {
     type: 'bpmn:IntermediateThrowEvent',
     eventDefinitionType: 'bpmn:CompensateEventDefinition'
   }
 },
 {
   label: 'Signal Intermediate Catch Event',
   actionName: 'replace-with-signal-intermediate-catch',
   className: 'bpmn-icon-intermediate-event-catch-signal',
   target: {
     type: 'bpmn:IntermediateCatchEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition'
   }
 },
 {
   label: 'Signal Intermediate Throw Event',
   actionName: 'replace-with-signal-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-throw-signal',
   target: {
     type: 'bpmn:IntermediateThrowEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition'
   }
 }
];
36328
var END_EVENT = [
 {
   label: 'Start Event',
   actionName: 'replace-with-none-start',
   className: 'bpmn-icon-start-event-none',
   target: {
     type: 'bpmn:StartEvent'
   }
 },
 {
   label: 'Intermediate Throw Event',
   actionName: 'replace-with-none-intermediate-throw',
   className: 'bpmn-icon-intermediate-event-none',
   target: {
     type: 'bpmn:IntermediateThrowEvent'
   }
 },
 {
   label: 'End Event',
   actionName: 'replace-with-none-end',
   className: 'bpmn-icon-end-event-none',
   target: {
     type: 'bpmn:EndEvent'
   }
 },
 {
   label: 'Message End Event',
   actionName: 'replace-with-message-end',
   className: 'bpmn-icon-end-event-message',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition'
   }
 },
 {
   label: 'Escalation End Event',
   actionName: 'replace-with-escalation-end',
   className: 'bpmn-icon-end-event-escalation',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:EscalationEventDefinition'
   }
 },
 {
   label: 'Error End Event',
   actionName: 'replace-with-error-end',
   className: 'bpmn-icon-end-event-error',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:ErrorEventDefinition'
   }
 },
 {
   label: 'Cancel End Event',
   actionName: 'replace-with-cancel-end',
   className: 'bpmn-icon-end-event-cancel',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:CancelEventDefinition'
   }
 },
 {
   label: 'Compensation End Event',
   actionName: 'replace-with-compensation-end',
   className: 'bpmn-icon-end-event-compensation',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:CompensateEventDefinition'
   }
 },
 {
   label: 'Signal End Event',
   actionName: 'replace-with-signal-end',
   className: 'bpmn-icon-end-event-signal',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition'
   }
 },
 {
   label: 'Terminate End Event',
   actionName: 'replace-with-terminate-end',
   className: 'bpmn-icon-end-event-terminate',
   target: {
     type: 'bpmn:EndEvent',
     eventDefinitionType: 'bpmn:TerminateEventDefinition'
   }
 }
];
36418
var GATEWAY = [
 {
   label: 'Exclusive Gateway',
   actionName: 'replace-with-exclusive-gateway',
   className: 'bpmn-icon-gateway-xor',
   target: {
     type: 'bpmn:ExclusiveGateway'
   }
 },
 {
   label: 'Parallel Gateway',
   actionName: 'replace-with-parallel-gateway',
   className: 'bpmn-icon-gateway-parallel',
   target: {
     type: 'bpmn:ParallelGateway'
   }
 },
 {
   label: 'Inclusive Gateway',
   actionName: 'replace-with-inclusive-gateway',
   className: 'bpmn-icon-gateway-or',
   target: {
     type: 'bpmn:InclusiveGateway'
   }
 },
 {
   label: 'Complex Gateway',
   actionName: 'replace-with-complex-gateway',
   className: 'bpmn-icon-gateway-complex',
   target: {
     type: 'bpmn:ComplexGateway'
   }
 },
 {
   label: 'Event based Gateway',
   actionName: 'replace-with-event-based-gateway',
   className: 'bpmn-icon-gateway-eventbased',
   target: {
     type: 'bpmn:EventBasedGateway',
     instantiate: false,
     eventGatewayType: 'Exclusive'
   }
 }
36462
 // Gateways deactivated until https://github.com/bpmn-io/bpmn-js/issues/194
 // {
 //   label: 'Event based instantiating Gateway',
 //   actionName: 'replace-with-exclusive-event-based-gateway',
 //   className: 'bpmn-icon-exclusive-event-based',
 //   target: {
 //     type: 'bpmn:EventBasedGateway'
 //   },
 //   options: {
 //     businessObject: { instantiate: true, eventGatewayType: 'Exclusive' }
 //   }
 // },
 // {
 //   label: 'Parallel Event based instantiating Gateway',
 //   actionName: 'replace-with-parallel-event-based-instantiate-gateway',
 //   className: 'bpmn-icon-parallel-event-based-instantiate-gateway',
 //   target: {
 //     type: 'bpmn:EventBasedGateway'
 //   },
 //   options: {
 //     businessObject: { instantiate: true, eventGatewayType: 'Parallel' }
 //   }
 // }
];
36487
var SUBPROCESS_EXPANDED = [
 {
   label: 'Transaction',
   actionName: 'replace-with-transaction',
   className: 'bpmn-icon-transaction',
   target: {
     type: 'bpmn:Transaction',
     isExpanded: true
   }
 },
 {
   label: 'Event Sub Process',
   actionName: 'replace-with-event-subprocess',
   className: 'bpmn-icon-event-subprocess-expanded',
   target: {
     type: 'bpmn:SubProcess',
     triggeredByEvent: true,
     isExpanded: true
   }
 },
 {
   label: 'Sub Process (collapsed)',
   actionName: 'replace-with-collapsed-subprocess',
   className: 'bpmn-icon-subprocess-collapsed',
   target: {
     type: 'bpmn:SubProcess',
     isExpanded: false
   }
 }
];
36518
var TRANSACTION = [
 {
   label: 'Sub Process',
   actionName: 'replace-with-subprocess',
   className: 'bpmn-icon-subprocess-expanded',
   target: {
     type: 'bpmn:SubProcess',
     isExpanded: true
   }
 },
 {
   label: 'Event Sub Process',
   actionName: 'replace-with-event-subprocess',
   className: 'bpmn-icon-event-subprocess-expanded',
   target: {
     type: 'bpmn:SubProcess',
     triggeredByEvent: true,
     isExpanded: true
   }
 }
];
36540
var EVENT_SUB_PROCESS = [
 {
   label: 'Sub Process',
   actionName: 'replace-with-subprocess',
   className: 'bpmn-icon-subprocess-expanded',
   target: {
     type: 'bpmn:SubProcess',
     isExpanded: true
   }
 },
 {
   label: 'Transaction',
   actionName: 'replace-with-transaction',
   className: 'bpmn-icon-transaction',
   target: {
     type: 'bpmn:Transaction',
     isExpanded: true
   }
 }
];
36561
var TASK = [
 {
   label: 'Task',
   actionName: 'replace-with-task',
   className: 'bpmn-icon-task',
   target: {
     type: 'bpmn:Task'
   }
 },
 {
   label: 'Send Task',
   actionName: 'replace-with-send-task',
   className: 'bpmn-icon-send',
   target: {
     type: 'bpmn:SendTask'
   }
 },
 {
   label: 'Receive Task',
   actionName: 'replace-with-receive-task',
   className: 'bpmn-icon-receive',
   target: {
     type: 'bpmn:ReceiveTask'
   }
 },
 {
   label: 'User Task',
   actionName: 'replace-with-user-task',
   className: 'bpmn-icon-user',
   target: {
     type: 'bpmn:UserTask'
   }
 },
 {
   label: 'Manual Task',
   actionName: 'replace-with-manual-task',
   className: 'bpmn-icon-manual',
   target: {
     type: 'bpmn:ManualTask'
   }
 },
 {
   label: 'Business Rule Task',
   actionName: 'replace-with-rule-task',
   className: 'bpmn-icon-business-rule',
   target: {
     type: 'bpmn:BusinessRuleTask'
   }
 },
 {
   label: 'Service Task',
   actionName: 'replace-with-service-task',
   className: 'bpmn-icon-service',
   target: {
     type: 'bpmn:ServiceTask'
   }
 },
 {
   label: 'Script Task',
   actionName: 'replace-with-script-task',
   className: 'bpmn-icon-script',
   target: {
     type: 'bpmn:ScriptTask'
   }
 },
 {
   label: 'Call Activity',
   actionName: 'replace-with-call-activity',
   className: 'bpmn-icon-call-activity',
   target: {
     type: 'bpmn:CallActivity'
   }
 },
 {
   label: 'Sub Process (collapsed)',
   actionName: 'replace-with-collapsed-subprocess',
   className: 'bpmn-icon-subprocess-collapsed',
   target: {
     type: 'bpmn:SubProcess',
     isExpanded: false
   }
 },
 {
   label: 'Sub Process (expanded)',
   actionName: 'replace-with-expanded-subprocess',
   className: 'bpmn-icon-subprocess-expanded',
   target: {
     type: 'bpmn:SubProcess',
     isExpanded: true
   }
 }
];
36654
var DATA_OBJECT_REFERENCE = [
 {
   label: 'Data Store Reference',
   actionName: 'replace-with-data-store-reference',
   className: 'bpmn-icon-data-store',
   target: {
     type: 'bpmn:DataStoreReference'
   }
 }
];
36665
var DATA_STORE_REFERENCE = [
 {
   label: 'Data Object Reference',
   actionName: 'replace-with-data-object-reference',
   className: 'bpmn-icon-data-object',
   target: {
     type: 'bpmn:DataObjectReference'
   }
 }
];
36676
var BOUNDARY_EVENT = [
 {
   label: 'Message Boundary Event',
   actionName: 'replace-with-message-boundary',
   className: 'bpmn-icon-intermediate-event-catch-message',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition'
   }
 },
 {
   label: 'Timer Boundary Event',
   actionName: 'replace-with-timer-boundary',
   className: 'bpmn-icon-intermediate-event-catch-timer',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:TimerEventDefinition'
   }
 },
 {
   label: 'Escalation Boundary Event',
   actionName: 'replace-with-escalation-boundary',
   className: 'bpmn-icon-intermediate-event-catch-escalation',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:EscalationEventDefinition'
   }
 },
 {
   label: 'Conditional Boundary Event',
   actionName: 'replace-with-conditional-boundary',
   className: 'bpmn-icon-intermediate-event-catch-condition',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:ConditionalEventDefinition'
   }
 },
 {
   label: 'Error Boundary Event',
   actionName: 'replace-with-error-boundary',
   className: 'bpmn-icon-intermediate-event-catch-error',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:ErrorEventDefinition'
   }
 },
 {
   label: 'Cancel Boundary Event',
   actionName: 'replace-with-cancel-boundary',
   className: 'bpmn-icon-intermediate-event-catch-cancel',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:CancelEventDefinition'
   }
 },
 {
   label: 'Signal Boundary Event',
   actionName: 'replace-with-signal-boundary',
   className: 'bpmn-icon-intermediate-event-catch-signal',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition'
   }
 },
 {
   label: 'Compensation Boundary Event',
   actionName: 'replace-with-compensation-boundary',
   className: 'bpmn-icon-intermediate-event-catch-compensation',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:CompensateEventDefinition'
   }
 },
 {
   label: 'Message Boundary Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-message-boundary',
   className: 'bpmn-icon-intermediate-event-catch-non-interrupting-message',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition',
     cancelActivity: false
   }
 },
 {
   label: 'Timer Boundary Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-timer-boundary',
   className: 'bpmn-icon-intermediate-event-catch-non-interrupting-timer',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:TimerEventDefinition',
     cancelActivity: false
   }
 },
 {
   label: 'Escalation Boundary Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-escalation-boundary',
   className: 'bpmn-icon-intermediate-event-catch-non-interrupting-escalation',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:EscalationEventDefinition',
     cancelActivity: false
   }
 },
 {
   label: 'Conditional Boundary Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-conditional-boundary',
   className: 'bpmn-icon-intermediate-event-catch-non-interrupting-condition',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:ConditionalEventDefinition',
     cancelActivity: false
   }
 },
 {
   label: 'Signal Boundary Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-signal-boundary',
   className: 'bpmn-icon-intermediate-event-catch-non-interrupting-signal',
   target: {
     type: 'bpmn:BoundaryEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition',
     cancelActivity: false
   }
 }
];
36801
var EVENT_SUB_PROCESS_START_EVENT = [
 {
   label: 'Message Start Event',
   actionName: 'replace-with-message-start',
   className: 'bpmn-icon-start-event-message',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition'
   }
 },
 {
   label: 'Timer Start Event',
   actionName: 'replace-with-timer-start',
   className: 'bpmn-icon-start-event-timer',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:TimerEventDefinition'
   }
 },
 {
   label: 'Conditional Start Event',
   actionName: 'replace-with-conditional-start',
   className: 'bpmn-icon-start-event-condition',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:ConditionalEventDefinition'
   }
 },
 {
   label: 'Signal Start Event',
   actionName: 'replace-with-signal-start',
   className: 'bpmn-icon-start-event-signal',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition'
   }
 },
 {
   label: 'Error Start Event',
   actionName: 'replace-with-error-start',
   className: 'bpmn-icon-start-event-error',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:ErrorEventDefinition'
   }
 },
 {
   label: 'Escalation Start Event',
   actionName: 'replace-with-escalation-start',
   className: 'bpmn-icon-start-event-escalation',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:EscalationEventDefinition'
   }
 },
 {
   label: 'Compensation Start Event',
   actionName: 'replace-with-compensation-start',
   className: 'bpmn-icon-start-event-compensation',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:CompensateEventDefinition'
   }
 },
 {
   label: 'Message Start Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-message-start',
   className: 'bpmn-icon-start-event-non-interrupting-message',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:MessageEventDefinition',
     isInterrupting: false
   }
 },
 {
   label: 'Timer Start Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-timer-start',
   className: 'bpmn-icon-start-event-non-interrupting-timer',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:TimerEventDefinition',
     isInterrupting: false
   }
 },
 {
   label: 'Conditional Start Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-conditional-start',
   className: 'bpmn-icon-start-event-non-interrupting-condition',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:ConditionalEventDefinition',
     isInterrupting: false
   }
 },
 {
   label: 'Signal Start Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-signal-start',
   className: 'bpmn-icon-start-event-non-interrupting-signal',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:SignalEventDefinition',
     isInterrupting: false
   }
 },
 {
   label: 'Escalation Start Event (non-interrupting)',
   actionName: 'replace-with-non-interrupting-escalation-start',
   className: 'bpmn-icon-start-event-non-interrupting-escalation',
   target: {
     type: 'bpmn:StartEvent',
     eventDefinitionType: 'bpmn:EscalationEventDefinition',
     isInterrupting: false
   }
 }
];
36917
var SEQUENCE_FLOW = [
 {
   label: 'Sequence Flow',
   actionName: 'replace-with-sequence-flow',
   className: 'bpmn-icon-connection'
 },
 {
   label: 'Default Flow',
   actionName: 'replace-with-default-flow',
   className: 'bpmn-icon-default-flow'
 },
 {
   label: 'Conditional Flow',
   actionName: 'replace-with-conditional-flow',
   className: 'bpmn-icon-conditional-flow'
 }
];
36935
var PARTICIPANT = [
 {
   label: 'Expanded Pool',
   actionName: 'replace-with-expanded-pool',
   className: 'bpmn-icon-participant',
   target: {
     type: 'bpmn:Participant',
     isExpanded: true
   }
 },
 {
   label: function(element) {
     var label = 'Empty Pool';
36949
     if (element.children && element.children.length) {
       label += ' (removes content)';
     }
36953
     return label;
   },
   actionName: 'replace-with-collapsed-pool',
36957
   // TODO(@janstuemmel): maybe design new icon
   className: 'bpmn-icon-lane',
   target: {
     type: 'bpmn:Participant',
     isExpanded: false
   }
 }
];
36966
/**
* This module is an element agnostic replace menu provider for the popup menu.
*/
function ReplaceMenuProvider(
   bpmnFactory, popupMenu, modeling, moddle,
   bpmnReplace, rules, translate) {
36973
 this._bpmnFactory = bpmnFactory;
 this._popupMenu = popupMenu;
 this._modeling = modeling;
 this._moddle = moddle;
 this._bpmnReplace = bpmnReplace;
 this._rules = rules;
 this._translate = translate;
36981
 this.register();
}
36984
ReplaceMenuProvider.$inject = [
 'bpmnFactory',
 'popupMenu',
 'modeling',
 'moddle',
 'bpmnReplace',
 'rules',
 'translate'
];
36994
36995
/**
* Register replace menu provider in the popup menu
*/
ReplaceMenuProvider.prototype.register = function() {
 this._popupMenu.registerProvider('bpmn-replace', this);
};
37002
37003
/**
* Get all entries from replaceOptions for the given element and apply filters
* on them. Get for example only elements, which are different from the current one.
*
* @param {djs.model.Base} element
*
* @return {Array<Object>} a list of menu entry items
*/
ReplaceMenuProvider.prototype.getEntries = function(element) {
37013
 var businessObject = element.businessObject;
37015
 var rules = this._rules;
37017
 var entries;
37019
 if (!rules.allowed('shape.replace', { element: element })) {
   return [];
 }
37023
 var differentType = isDifferentType(element);
37025
 if (is$1(businessObject, 'bpmn:DataObjectReference')) {
   return this._createEntries(element, DATA_OBJECT_REFERENCE);
 }
37029
 if (is$1(businessObject, 'bpmn:DataStoreReference') && !is$1(element.parent, 'bpmn:Collaboration')) {
   return this._createEntries(element, DATA_STORE_REFERENCE);
 }
37033
 // start events outside sub processes
 if (is$1(businessObject, 'bpmn:StartEvent') && !is$1(businessObject.$parent, 'bpmn:SubProcess')) {
37036
   entries = filter(START_EVENT, differentType);
37038
   return this._createEntries(element, entries);
 }
37041
 // expanded/collapsed pools
 if (is$1(businessObject, 'bpmn:Participant')) {
37044
   entries = filter(PARTICIPANT, function(entry) {
     return isExpanded(element) !== entry.target.isExpanded;
   });
37048
   return this._createEntries(element, entries);
 }
37051
 // start events inside event sub processes
 if (is$1(businessObject, 'bpmn:StartEvent') && isEventSubProcess(businessObject.$parent)) {
   entries = filter(EVENT_SUB_PROCESS_START_EVENT, function(entry) {
37055
     var target = entry.target;
37057
     var isInterrupting = target.isInterrupting !== false;
37059
     var isInterruptingEqual = getBusinessObject(element).isInterrupting === isInterrupting;
37061
     // filters elements which types and event definition are equal but have have different interrupting types
     return differentType(entry) || !differentType(entry) && !isInterruptingEqual;
37064
   });
37066
   return this._createEntries(element, entries);
 }
37069
 // start events inside sub processes
 if (is$1(businessObject, 'bpmn:StartEvent') && !isEventSubProcess(businessObject.$parent)
     && is$1(businessObject.$parent, 'bpmn:SubProcess')) {
   entries = filter(START_EVENT_SUB_PROCESS, differentType);
37074
   return this._createEntries(element, entries);
 }
37077
 // end events
 if (is$1(businessObject, 'bpmn:EndEvent')) {
37080
   entries = filter(END_EVENT, function(entry) {
     var target = entry.target;
37083
     // hide cancel end events outside transactions
     if (target.eventDefinitionType == 'bpmn:CancelEventDefinition' && !is$1(businessObject.$parent, 'bpmn:Transaction')) {
       return false;
     }
37088
     return differentType(entry);
   });
37091
   return this._createEntries(element, entries);
 }
37094
 // boundary events
 if (is$1(businessObject, 'bpmn:BoundaryEvent')) {
37097
   entries = filter(BOUNDARY_EVENT, function(entry) {
37099
     var target = entry.target;
37101
     if (target.eventDefinitionType == 'bpmn:CancelEventDefinition' &&
        !is$1(businessObject.attachedToRef, 'bpmn:Transaction')) {
       return false;
     }
     var cancelActivity = target.cancelActivity !== false;
37107
     var isCancelActivityEqual = businessObject.cancelActivity == cancelActivity;
37109
     return differentType(entry) || !differentType(entry) && !isCancelActivityEqual;
   });
37112
   return this._createEntries(element, entries);
 }
37115
 // intermediate events
 if (is$1(businessObject, 'bpmn:IntermediateCatchEvent') ||
     is$1(businessObject, 'bpmn:IntermediateThrowEvent')) {
37119
   entries = filter(INTERMEDIATE_EVENT, differentType);
37121
   return this._createEntries(element, entries);
 }
37124
 // gateways
 if (is$1(businessObject, 'bpmn:Gateway')) {
37127
   entries = filter(GATEWAY, differentType);
37129
   return this._createEntries(element, entries);
 }
37132
 // transactions
 if (is$1(businessObject, 'bpmn:Transaction')) {
37135
   entries = filter(TRANSACTION, differentType);
37137
   return this._createEntries(element, entries);
 }
37140
 // expanded event sub processes
 if (isEventSubProcess(businessObject) && isExpanded(element)) {
37143
   entries = filter(EVENT_SUB_PROCESS, differentType);
37145
   return this._createEntries(element, entries);
 }
37148
 // expanded sub processes
 if (is$1(businessObject, 'bpmn:SubProcess') && isExpanded(element)) {
37151
   entries = filter(SUBPROCESS_EXPANDED, differentType);
37153
   return this._createEntries(element, entries);
 }
37156
 // collapsed ad hoc sub processes
 if (is$1(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(element)) {
37159
   entries = filter(TASK, function(entry) {
37161
     var target = entry.target;
37163
     var isTargetSubProcess = target.type === 'bpmn:SubProcess';
37165
     var isTargetExpanded = target.isExpanded === true;
37167
     return isDifferentType(element) && (!isTargetSubProcess || isTargetExpanded);
   });
37170
   return this._createEntries(element, entries);
 }
37173
 // sequence flows
 if (is$1(businessObject, 'bpmn:SequenceFlow')) {
   return this._createSequenceFlowEntries(element, SEQUENCE_FLOW);
 }
37178
 // flow nodes
 if (is$1(businessObject, 'bpmn:FlowNode')) {
   entries = filter(TASK, differentType);
37182
   // collapsed SubProcess can not be replaced with itself
   if (is$1(businessObject, 'bpmn:SubProcess') && !isExpanded(element)) {
     entries = filter(entries, function(entry) {
       return entry.label !== 'Sub Process (collapsed)';
     });
   }
37189
   return this._createEntries(element, entries);
 }
37192
 return [];
};
37195
37196
/**
* Get a list of header items for the given element. This includes buttons
* for multi instance markers and for the ad hoc marker.
*
* @param {djs.model.Base} element
*
* @return {Array<Object>} a list of menu entry items
*/
ReplaceMenuProvider.prototype.getHeaderEntries = function(element) {
37206
 var headerEntries = [];
37208
 if (is$1(element, 'bpmn:Activity') && !isEventSubProcess(element)) {
   headerEntries = headerEntries.concat(this._getLoopEntries(element));
 }
37212
 if (is$1(element, 'bpmn:DataObjectReference')) {
   headerEntries = headerEntries.concat(this._getDataObjectIsCollection(element));
 }
37216
 if (is$1(element, 'bpmn:Participant')) {
   headerEntries = headerEntries.concat(this._getParticipantMultiplicity(element));
 }
37220
 if (is$1(element, 'bpmn:SubProcess') &&
     !is$1(element, 'bpmn:Transaction') &&
     !isEventSubProcess(element)) {
   headerEntries.push(this._getAdHocEntry(element));
 }
37226
 return headerEntries;
};
37229
37230
/**
* Creates an array of menu entry objects for a given element and filters the replaceOptions
* according to a filter function.
*
* @param  {djs.model.Base} element
* @param  {Object} replaceOptions
*
* @return {Array<Object>} a list of menu items
*/
ReplaceMenuProvider.prototype._createEntries = function(element, replaceOptions) {
 var menuEntries = [];
37242
 var self = this;
37244
 forEach$2(replaceOptions, function(definition) {
   var entry = self._createMenuEntry(definition, element);
37247
   menuEntries.push(entry);
 });
37250
 return menuEntries;
};
37253
/**
* Creates an array of menu entry objects for a given sequence flow.
*
* @param  {djs.model.Base} element
* @param  {Object} replaceOptions
37259
* @return {Array<Object>} a list of menu items
*/
ReplaceMenuProvider.prototype._createSequenceFlowEntries = function(element, replaceOptions) {
37263
 var businessObject = getBusinessObject(element);
37265
 var menuEntries = [];
37267
 var modeling = this._modeling,
     moddle = this._moddle;
37270
 var self = this;
37272
 forEach$2(replaceOptions, function(entry) {
37274
   switch (entry.actionName) {
   case 'replace-with-default-flow':
     if (businessObject.sourceRef.default !== businessObject &&
           (is$1(businessObject.sourceRef, 'bpmn:ExclusiveGateway') ||
            is$1(businessObject.sourceRef, 'bpmn:InclusiveGateway') ||
            is$1(businessObject.sourceRef, 'bpmn:ComplexGateway') ||
            is$1(businessObject.sourceRef, 'bpmn:Activity'))) {
37282
       menuEntries.push(self._createMenuEntry(entry, element, function() {
         modeling.updateProperties(element.source, { default: businessObject });
       }));
     }
     break;
   case 'replace-with-conditional-flow':
     if (!businessObject.conditionExpression && is$1(businessObject.sourceRef, 'bpmn:Activity')) {
37290
       menuEntries.push(self._createMenuEntry(entry, element, function() {
         var conditionExpression = moddle.create('bpmn:FormalExpression', { body: '' });
37293
         modeling.updateProperties(element, { conditionExpression: conditionExpression });
       }));
     }
     break;
   default:
37299
     // default flows
     if (is$1(businessObject.sourceRef, 'bpmn:Activity') && businessObject.conditionExpression) {
       return menuEntries.push(self._createMenuEntry(entry, element, function() {
         modeling.updateProperties(element, { conditionExpression: undefined });
       }));
     }
37306
     // conditional flows
     if ((is$1(businessObject.sourceRef, 'bpmn:ExclusiveGateway') ||
          is$1(businessObject.sourceRef, 'bpmn:InclusiveGateway') ||
          is$1(businessObject.sourceRef, 'bpmn:ComplexGateway') ||
          is$1(businessObject.sourceRef, 'bpmn:Activity')) &&
          businessObject.sourceRef.default === businessObject) {
37313
       return menuEntries.push(self._createMenuEntry(entry, element, function() {
         modeling.updateProperties(element.source, { default: undefined });
       }));
     }
   }
 });
37320
 return menuEntries;
};
37323
37324
/**
* Creates and returns a single menu entry item.
*
* @param  {Object} definition a single replace options definition object
* @param  {djs.model.Base} element
* @param  {Function} [action] an action callback function which gets called when
*                             the menu entry is being triggered.
*
* @return {Object} menu entry item
*/
ReplaceMenuProvider.prototype._createMenuEntry = function(definition, element, action) {
 var translate = this._translate;
 var replaceElement = this._bpmnReplace.replaceElement;
37338
 var replaceAction = function() {
   return replaceElement(element, definition.target);
 };
37342
 var label = definition.label;
 if (label && typeof label === 'function') {
   label = label(element);
 }
37347
 action = action || replaceAction;
37349
 var menuEntry = {
   label: translate(label),
   className: definition.className,
   id: definition.actionName,
   action: action
 };
37356
 return menuEntry;
};
37359
/**
* Get a list of menu items containing buttons for multi instance markers
*
* @param  {djs.model.Base} element
*
* @return {Array<Object>} a list of menu items
*/
ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
37368
 var self = this;
 var translate = this._translate;
37371
 function toggleLoopEntry(event, entry) {
   var loopCharacteristics = getBusinessObject(element).loopCharacteristics;
37374
   if (entry.active) {
     loopCharacteristics = undefined;
   } else {
     if (isUndefined$3(entry.options.isSequential) || !loopCharacteristics) {
       loopCharacteristics = self._moddle.create(entry.options.loopCharacteristics);
     }
37381
     loopCharacteristics.isSequential = entry.options.isSequential;
   }
   self._modeling.updateProperties(element, { loopCharacteristics: loopCharacteristics });
 }
37386
 var businessObject = getBusinessObject(element),
     loopCharacteristics = businessObject.loopCharacteristics;
37389
 var isSequential,
     isLoop,
     isParallel;
37393
 if (loopCharacteristics) {
   isSequential = loopCharacteristics.isSequential;
   isLoop = loopCharacteristics.isSequential === undefined;
   isParallel = loopCharacteristics.isSequential !== undefined && !loopCharacteristics.isSequential;
 }
37399
37400
 var loopEntries = [
   {
     id: 'toggle-parallel-mi',
     className: 'bpmn-icon-parallel-mi-marker',
     title: translate('Parallel Multi Instance'),
     active: isParallel,
     action: toggleLoopEntry,
     options: {
       loopCharacteristics: 'bpmn:MultiInstanceLoopCharacteristics',
       isSequential: false
     }
   },
   {
     id: 'toggle-sequential-mi',
     className: 'bpmn-icon-sequential-mi-marker',
     title: translate('Sequential Multi Instance'),
     active: isSequential,
     action: toggleLoopEntry,
     options: {
       loopCharacteristics: 'bpmn:MultiInstanceLoopCharacteristics',
       isSequential: true
     }
   },
   {
     id: 'toggle-loop',
     className: 'bpmn-icon-loop-marker',
     title: translate('Loop'),
     active: isLoop,
     action: toggleLoopEntry,
     options: {
       loopCharacteristics: 'bpmn:StandardLoopCharacteristics'
     }
   }
 ];
 return loopEntries;
};
37437
/**
* Get a list of menu items containing a button for the collection marker
*
* @param  {djs.model.Base} element
*
* @return {Array<Object>} a list of menu items
*/
ReplaceMenuProvider.prototype._getDataObjectIsCollection = function(element) {
37446
 var self = this;
 var translate = this._translate;
37449
 function toggleIsCollection(event, entry) {
   self._modeling.updateModdleProperties(
     element,
     dataObject,
     { isCollection: !entry.active });
 }
37456
 var dataObject = element.businessObject.dataObjectRef,
     isCollection = dataObject.isCollection;
37459
 var dataObjectEntries = [
   {
     id: 'toggle-is-collection',
     className: 'bpmn-icon-parallel-mi-marker',
     title: translate('Collection'),
     active: isCollection,
     action: toggleIsCollection,
   }
 ];
 return dataObjectEntries;
};
37471
/**
* Get a list of menu items containing a button for the participant multiplicity marker
*
* @param  {djs.model.Base} element
*
* @return {Array<Object>} a list of menu items
*/
ReplaceMenuProvider.prototype._getParticipantMultiplicity = function(element) {
37480
 var self = this;
 var bpmnFactory = this._bpmnFactory;
 var translate = this._translate;
37484
 function toggleParticipantMultiplicity(event, entry) {
   var isActive = entry.active;
   var participantMultiplicity;
37488
   if (!isActive) {
     participantMultiplicity = bpmnFactory.create('bpmn:ParticipantMultiplicity');
   }
37492
   self._modeling.updateProperties(
     element,
     { participantMultiplicity: participantMultiplicity });
 }
37497
 var participantMultiplicity = element.businessObject.participantMultiplicity;
37499
 var participantEntries = [
   {
     id: 'toggle-participant-multiplicity',
     className: 'bpmn-icon-parallel-mi-marker',
     title: translate('Participant Multiplicity'),
     active: !!participantMultiplicity,
     action: toggleParticipantMultiplicity,
   }
 ];
 return participantEntries;
};
37511
37512
/**
* Get the menu items containing a button for the ad hoc marker
*
* @param  {djs.model.Base} element
*
* @return {Object} a menu item
*/
ReplaceMenuProvider.prototype._getAdHocEntry = function(element) {
 var translate = this._translate;
 var businessObject = getBusinessObject(element);
37523
 var isAdHoc = is$1(businessObject, 'bpmn:AdHocSubProcess');
37525
 var replaceElement = this._bpmnReplace.replaceElement;
37527
 var adHocEntry = {
   id: 'toggle-adhoc',
   className: 'bpmn-icon-ad-hoc-marker',
   title: translate('Ad-hoc'),
   active: isAdHoc,
   action: function(event, entry) {
     if (isAdHoc) {
       return replaceElement(element, { type: 'bpmn:SubProcess' }, {
         autoResize: false,
         layoutConnection: false
       });
     } else {
       return replaceElement(element, { type: 'bpmn:AdHocSubProcess' }, {
         autoResize: false,
         layoutConnection: false
       });
     }
   }
 };
37547
 return adHocEntry;
};
37550
var PopupMenuModule = {
 __depends__: [
   PopupMenuModule$1,
   ReplaceModule
 ],
 __init__: [ 'replaceMenuProvider' ],
 replaceMenuProvider: [ 'type', ReplaceMenuProvider ]
};
37559
var max$4 = Math.max,
   min$2 = Math.min;
37562
var DEFAULT_CHILD_BOX_PADDING = 20;
37564
37565
/**
* Substract a TRBL from another
*
* @param  {TRBL} trblA
* @param  {TRBL} trblB
*
* @return {TRBL}
*/
function substractTRBL(trblA, trblB) {
 return {
   top: trblA.top - trblB.top,
   right: trblA.right - trblB.right,
   bottom: trblA.bottom - trblB.bottom,
   left: trblA.left - trblB.left
 };
}
37582
/**
* Resize the given bounds by the specified delta from a given anchor point.
*
* @param {Bounds} bounds the bounding box that should be resized
* @param {string} direction in which the element is resized (nw, ne, se, sw)
* @param {Point} delta of the resize operation
*
* @return {Bounds} resized bounding box
*/
function resizeBounds$1(bounds, direction, delta) {
 var dx = delta.x,
     dy = delta.y;
37595
 var newBounds = {
   x: bounds.x,
   y: bounds.y,
   width: bounds.width,
   height: bounds.height
 };
37602
 if (direction.indexOf('n') !== -1) {
   newBounds.y = bounds.y + dy;
   newBounds.height = bounds.height - dy;
 } else if (direction.indexOf('s') !== -1) {
   newBounds.height = bounds.height + dy;
 }
37609
 if (direction.indexOf('e') !== -1) {
   newBounds.width = bounds.width + dx;
 } else if (direction.indexOf('w') !== -1) {
   newBounds.x = bounds.x + dx;
   newBounds.width = bounds.width - dx;
 }
37616
 return newBounds;
}
37619
37620
/**
* Resize the given bounds by applying the passed
* { top, right, bottom, left } delta.
*
* @param {Bounds} bounds
* @param {TRBL} trblResize
*
* @return {Bounds}
*/
function resizeTRBL(bounds, resize) {
 return {
   x: bounds.x + (resize.left || 0),
   y: bounds.y + (resize.top || 0),
   width: bounds.width - (resize.left || 0) + (resize.right || 0),
   height: bounds.height - (resize.top || 0) + (resize.bottom || 0)
 };
}
37638
37639
function applyConstraints(attr, trbl, resizeConstraints) {
37641
 var value = trbl[attr],
     minValue = resizeConstraints.min && resizeConstraints.min[attr],
     maxValue = resizeConstraints.max && resizeConstraints.max[attr];
37645
 if (isNumber(minValue)) {
   value = (/top|left/.test(attr) ? min$2 : max$4)(value, minValue);
 }
37649
 if (isNumber(maxValue)) {
   value = (/top|left/.test(attr) ? max$4 : min$2)(value, maxValue);
 }
37653
 return value;
}
37656
function ensureConstraints$1(currentBounds, resizeConstraints) {
37658
 if (!resizeConstraints) {
   return currentBounds;
 }
37662
 var currentTrbl = asTRBL(currentBounds);
37664
 return asBounds({
   top: applyConstraints('top', currentTrbl, resizeConstraints),
   right: applyConstraints('right', currentTrbl, resizeConstraints),
   bottom: applyConstraints('bottom', currentTrbl, resizeConstraints),
   left: applyConstraints('left', currentTrbl, resizeConstraints)
 });
}
37672
37673
function getMinResizeBounds(direction, currentBounds, minDimensions, childrenBounds) {
37675
 var currentBox = asTRBL(currentBounds);
37677
 var minBox = {
   top: /n/.test(direction) ? currentBox.bottom - minDimensions.height : currentBox.top,
   left: /w/.test(direction) ? currentBox.right - minDimensions.width : currentBox.left,
   bottom: /s/.test(direction) ? currentBox.top + minDimensions.height : currentBox.bottom,
   right: /e/.test(direction) ? currentBox.left + minDimensions.width : currentBox.right
 };
37684
 var childrenBox = childrenBounds ? asTRBL(childrenBounds) : minBox;
37686
 var combinedBox = {
   top: min$2(minBox.top, childrenBox.top),
   left: min$2(minBox.left, childrenBox.left),
   bottom: max$4(minBox.bottom, childrenBox.bottom),
   right: max$4(minBox.right, childrenBox.right)
 };
37693
 return asBounds(combinedBox);
}
37696
function asPadding(mayBePadding, defaultValue) {
 if (typeof mayBePadding !== 'undefined') {
   return mayBePadding;
 } else {
   return DEFAULT_CHILD_BOX_PADDING;
 }
}
37704
function addPadding$1(bbox, padding) {
 var left, right, top, bottom;
37707
 if (typeof padding === 'object') {
   left = asPadding(padding.left);
   right = asPadding(padding.right);
   top = asPadding(padding.top);
   bottom = asPadding(padding.bottom);
 } else {
   left = right = top = bottom = asPadding(padding);
 }
37716
 return {
   x: bbox.x - left,
   y: bbox.y - top,
   width: bbox.width + left + right,
   height: bbox.height + top + bottom
 };
}
37724
37725
/**
* Is the given element part of the resize
* targets min boundary box?
*
* This is the default implementation which excludes
* connections and labels.
*
* @param {djs.model.Base} element
*/
function isBBoxChild(element) {
37736
 // exclude connections
 if (element.waypoints) {
   return false;
 }
37741
 // exclude labels
 if (element.type === 'label') {
   return false;
 }
37746
 return true;
}
37749
/**
* Return children bounding computed from a shapes children
* or a list of prefiltered children.
*
* @param  {djs.model.Shape|Array<djs.model.Shape>} shapeOrChildren
* @param  {number|Object} padding
*
* @return {Bounds}
*/
function computeChildrenBBox(shapeOrChildren, padding) {
37760
 var elements;
37762
 // compute based on shape
 if (shapeOrChildren.length === undefined) {
37765
   // grab all the children that are part of the
   // parents children box
   elements = filter(shapeOrChildren.children, isBBoxChild);
37769
 } else {
   elements = shapeOrChildren;
 }
37773
 if (elements.length) {
   return addPadding$1(getBBox(elements), padding);
 }
}
37778
var abs$4 = Math.abs;
37780
37781
function getTRBLResize(oldBounds, newBounds) {
 return substractTRBL(asTRBL(newBounds), asTRBL(oldBounds));
}
37785
37786
var LANE_PARENTS = [
 'bpmn:Participant',
 'bpmn:Process',
 'bpmn:SubProcess'
];
37792
var LANE_INDENTATION = 30;
37794
37795
/**
* Collect all lane shapes in the given paren
*
* @param  {djs.model.Shape} shape
* @param  {Array<djs.model.Base>} [collectedShapes]
*
* @return {Array<djs.model.Base>}
*/
function collectLanes(shape, collectedShapes) {
37805
 collectedShapes = collectedShapes || [];
37807
 shape.children.filter(function(s) {
   if (is$1(s, 'bpmn:Lane')) {
     collectLanes(s, collectedShapes);
37811
     collectedShapes.push(s);
   }
 });
37815
 return collectedShapes;
}
37818
37819
/**
* Return the lane children of the given element.
*
* @param {djs.model.Shape} shape
*
* @return {Array<djs.model.Shape>}
*/
function getChildLanes(shape) {
 return shape.children.filter(function(c) {
   return is$1(c, 'bpmn:Lane');
 });
}
37832
37833
/**
* Return the root element containing the given lane shape
*
* @param {djs.model.Shape} shape
*
* @return {djs.model.Shape}
*/
function getLanesRoot(shape) {
 return getParent(shape, LANE_PARENTS) || shape;
}
37844
37845
/**
* Compute the required resize operations for lanes
* adjacent to the given shape, assuming it will be
* resized to the given new bounds.
*
* @param {djs.model.Shape} shape
* @param {Bounds} newBounds
*
* @return {Array<Object>}
*/
function computeLanesResize(shape, newBounds) {
37857
 var rootElement = getLanesRoot(shape);
37859
 var initialShapes = is$1(rootElement, 'bpmn:Process') ? [] : [ rootElement ];
37861
 var allLanes = collectLanes(rootElement, initialShapes),
     shapeTrbl = asTRBL(shape),
     shapeNewTrbl = asTRBL(newBounds),
     trblResize = getTRBLResize(shape, newBounds),
     resizeNeeded = [];
37867
 allLanes.forEach(function(other) {
37869
   if (other === shape) {
     return;
   }
37873
   var topResize = 0,
       rightResize = trblResize.right,
       bottomResize = 0,
       leftResize = trblResize.left;
37878
   var otherTrbl = asTRBL(other);
37880
   if (trblResize.top) {
     if (abs$4(otherTrbl.bottom - shapeTrbl.top) < 10) {
       bottomResize = shapeNewTrbl.top - otherTrbl.bottom;
     }
37885
     if (abs$4(otherTrbl.top - shapeTrbl.top) < 5) {
       topResize = shapeNewTrbl.top - otherTrbl.top;
     }
   }
37890
   if (trblResize.bottom) {
     if (abs$4(otherTrbl.top - shapeTrbl.bottom) < 10) {
       topResize = shapeNewTrbl.bottom - otherTrbl.top;
     }
37895
     if (abs$4(otherTrbl.bottom - shapeTrbl.bottom) < 5) {
       bottomResize = shapeNewTrbl.bottom - otherTrbl.bottom;
     }
   }
37900
   if (topResize || rightResize || bottomResize || leftResize) {
37902
     resizeNeeded.push({
       shape: other,
       newBounds: resizeTRBL(other, {
         top: topResize,
         right: rightResize,
         bottom: bottomResize,
         left: leftResize
       })
     });
   }
37913
 });
37915
 return resizeNeeded;
}
37918
/**
* A provider for BPMN 2.0 elements context pad
*/
function ContextPadProvider(
   config, injector, eventBus,
   contextPad, modeling, elementFactory,
   connect, create, popupMenu,
   canvas, rules, translate) {
37927
 config = config || {};
37929
 contextPad.registerProvider(this);
37931
 this._contextPad = contextPad;
37933
 this._modeling = modeling;
37935
 this._elementFactory = elementFactory;
 this._connect = connect;
 this._create = create;
 this._popupMenu = popupMenu;
 this._canvas = canvas;
 this._rules = rules;
 this._translate = translate;
37943
 if (config.autoPlace !== false) {
   this._autoPlace = injector.get('autoPlace', false);
 }
37947
 eventBus.on('create.end', 250, function(event) {
   var context = event.context,
       shape = context.shape;
37951
   if (!hasPrimaryModifier(event) || !contextPad.isOpen(shape)) {
     return;
   }
37955
   var entries = contextPad.getEntries(shape);
37957
   if (entries.replace) {
     entries.replace.action.click(event, shape);
   }
 });
}
37963
ContextPadProvider.$inject = [
 'config.contextPad',
 'injector',
 'eventBus',
 'contextPad',
 'modeling',
 'elementFactory',
 'connect',
 'create',
 'popupMenu',
 'canvas',
 'rules',
 'translate'
];
37978
37979
ContextPadProvider.prototype.getContextPadEntries = function(element) {
37981
 var contextPad = this._contextPad,
     modeling = this._modeling,
37984
     elementFactory = this._elementFactory,
     connect = this._connect,
     create = this._create,
     popupMenu = this._popupMenu,
     canvas = this._canvas,
     rules = this._rules,
     autoPlace = this._autoPlace,
     translate = this._translate;
37993
 var actions = {};
37995
 if (element.type === 'label') {
   return actions;
 }
37999
 var businessObject = element.businessObject;
38001
 function startConnect(event, element) {
   connect.start(event, element);
 }
38005
 function removeElement(e) {
   modeling.removeElements([ element ]);
 }
38009
 function getReplaceMenuPosition(element) {
38011
   var Y_OFFSET = 5;
38013
   var diagramContainer = canvas.getContainer(),
       pad = contextPad.getPad(element).html;
38016
   var diagramRect = diagramContainer.getBoundingClientRect(),
       padRect = pad.getBoundingClientRect();
38019
   var top = padRect.top - diagramRect.top;
   var left = padRect.left - diagramRect.left;
38022
   var pos = {
     x: left,
     y: top + padRect.height + Y_OFFSET
   };
38027
   return pos;
 }
38030
38031
 /**
  * Create an append action
  *
  * @param {string} type
  * @param {string} className
  * @param {string} [title]
  * @param {Object} [options]
  *
  * @return {Object} descriptor
  */
 function appendAction(type, className, title, options) {
38043
   if (typeof title !== 'string') {
     options = title;
     title = translate('Append {type}', { type: type.replace(/^bpmn:/, '') });
   }
38048
   function appendStart(event, element) {
38050
     var shape = elementFactory.createShape(assign({ type: type }, options));
     create.start(event, shape, {
       source: element
     });
   }
38056
38057
   var append = autoPlace ? function(event, element) {
     var shape = elementFactory.createShape(assign({ type: type }, options));
38060
     autoPlace.append(element, shape);
   } : appendStart;
38063
38064
   return {
     group: 'model',
     className: className,
     title: title,
     action: {
       dragstart: appendStart,
       click: append
     }
   };
 }
38075
 function splitLaneHandler(count) {
38077
   return function(event, element) {
38079
     // actual split
     modeling.splitLane(element, count);
38082
     // refresh context pad after split to
     // get rid of split icons
     contextPad.open(element, true);
   };
 }
38088
38089
 if (isAny(businessObject, [ 'bpmn:Lane', 'bpmn:Participant' ]) && isExpanded(element)) {
38091
   var childLanes = getChildLanes(element);
38093
   assign(actions, {
     'lane-insert-above': {
       group: 'lane-insert-above',
       className: 'bpmn-icon-lane-insert-above',
       title: translate('Add Lane above'),
       action: {
         click: function(event, element) {
           modeling.addLane(element, 'top');
         }
       }
     }
   });
38106
   if (childLanes.length < 2) {
38108
     if (element.height >= 120) {
       assign(actions, {
         'lane-divide-two': {
           group: 'lane-divide',
           className: 'bpmn-icon-lane-divide-two',
           title: translate('Divide into two Lanes'),
           action: {
             click: splitLaneHandler(2)
           }
         }
       });
     }
38121
     if (element.height >= 180) {
       assign(actions, {
         'lane-divide-three': {
           group: 'lane-divide',
           className: 'bpmn-icon-lane-divide-three',
           title: translate('Divide into three Lanes'),
           action: {
             click: splitLaneHandler(3)
           }
         }
       });
     }
   }
38135
   assign(actions, {
     'lane-insert-below': {
       group: 'lane-insert-below',
       className: 'bpmn-icon-lane-insert-below',
       title: translate('Add Lane below'),
       action: {
         click: function(event, element) {
           modeling.addLane(element, 'bottom');
         }
       }
     }
   });
38148
 }
38150
 if (is$1(businessObject, 'bpmn:FlowNode')) {
38152
   if (is$1(businessObject, 'bpmn:EventBasedGateway')) {
38154
     assign(actions, {
       'append.receive-task': appendAction(
         'bpmn:ReceiveTask',
         'bpmn-icon-receive-task',
         translate('Append ReceiveTask')
       ),
       'append.message-intermediate-event': appendAction(
         'bpmn:IntermediateCatchEvent',
         'bpmn-icon-intermediate-event-catch-message',
         translate('Append MessageIntermediateCatchEvent'),
         { eventDefinitionType: 'bpmn:MessageEventDefinition' }
       ),
       'append.timer-intermediate-event': appendAction(
         'bpmn:IntermediateCatchEvent',
         'bpmn-icon-intermediate-event-catch-timer',
         translate('Append TimerIntermediateCatchEvent'),
         { eventDefinitionType: 'bpmn:TimerEventDefinition' }
       ),
       'append.condition-intermediate-event': appendAction(
         'bpmn:IntermediateCatchEvent',
         'bpmn-icon-intermediate-event-catch-condition',
         translate('Append ConditionIntermediateCatchEvent'),
         { eventDefinitionType: 'bpmn:ConditionalEventDefinition' }
       ),
       'append.signal-intermediate-event': appendAction(
         'bpmn:IntermediateCatchEvent',
         'bpmn-icon-intermediate-event-catch-signal',
         translate('Append SignalIntermediateCatchEvent'),
         { eventDefinitionType: 'bpmn:SignalEventDefinition' }
       )
     });
   } else
38187
   if (isEventType(businessObject, 'bpmn:BoundaryEvent', 'bpmn:CompensateEventDefinition')) {
38189
     assign(actions, {
       'append.compensation-activity':
           appendAction(
             'bpmn:Task',
             'bpmn-icon-task',
             translate('Append compensation activity'),
             {
               isForCompensation: true
             }
           )
     });
   } else
38202
   if (!is$1(businessObject, 'bpmn:EndEvent') &&
       !businessObject.isForCompensation &&
       !isEventType(businessObject, 'bpmn:IntermediateThrowEvent', 'bpmn:LinkEventDefinition') &&
       !isEventSubProcess(businessObject)) {
38207
     assign(actions, {
       'append.end-event': appendAction(
         'bpmn:EndEvent',
         'bpmn-icon-end-event-none',
         translate('Append EndEvent')
       ),
       'append.gateway': appendAction(
         'bpmn:ExclusiveGateway',
         'bpmn-icon-gateway-none',
         translate('Append Gateway')
       ),
       'append.append-task': appendAction(
         'bpmn:Task',
         'bpmn-icon-task',
         translate('Append Task')
       ),
       'append.intermediate-event': appendAction(
         'bpmn:IntermediateThrowEvent',
         'bpmn-icon-intermediate-event-none',
         translate('Append Intermediate/Boundary Event')
       )
     });
   }
 }
38232
 if (!popupMenu.isEmpty(element, 'bpmn-replace')) {
38234
   // Replace menu entry
   assign(actions, {
     'replace': {
       group: 'edit',
       className: 'bpmn-icon-screw-wrench',
       title: translate('Change type'),
       action: {
         click: function(event, element) {
38243
           var position = assign(getReplaceMenuPosition(element), {
             cursor: { x: event.x, y: event.y }
           });
38247
           popupMenu.open(element, 'bpmn-replace', position);
         }
       }
     }
   });
 }
38254
 if (
   isAny(businessObject, [
     'bpmn:FlowNode',
     'bpmn:InteractionNode',
     'bpmn:DataObjectReference',
     'bpmn:DataStoreReference',
   ])
 ) {
   assign(actions, {
     'append.text-annotation': appendAction(
       'bpmn:TextAnnotation',
       'bpmn-icon-text-annotation'
     ),
38268
     'connect': {
       group: 'connect',
       className: 'bpmn-icon-connection-multi',
       title: translate(
         'Connect using ' +
           (businessObject.isForCompensation
             ? ''
             : 'Sequence/MessageFlow or ') +
           'Association'
       ),
       action: {
         click: startConnect,
         dragstart: startConnect,
       },
     },
   });
 }
38286
 if (is$1(businessObject, 'bpmn:TextAnnotation')) {
   assign(actions, {
     'connect': {
       group: 'connect',
       className: 'bpmn-icon-connection-multi',
       title: translate('Connect using Association'),
       action: {
         click: startConnect,
         dragstart: startConnect,
       },
     },
   });
 }
38300
 if (isAny(businessObject, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ])) {
   assign(actions, {
     'connect': {
       group: 'connect',
       className: 'bpmn-icon-connection-multi',
       title: translate('Connect using DataInputAssociation'),
       action: {
         click: startConnect,
         dragstart: startConnect
       }
     }
   });
 }
38314
 if (is$1(businessObject, 'bpmn:Group')) {
   assign(actions, {
     'append.text-annotation': appendAction('bpmn:TextAnnotation', 'bpmn-icon-text-annotation')
   });
 }
38320
 // delete element entry, only show if allowed by rules
 var deleteAllowed = rules.allowed('elements.delete', { elements: [ element ] });
38323
 if (isArray$4(deleteAllowed)) {
38325
   // was the element returned as a deletion candidate?
   deleteAllowed = deleteAllowed[0] === element;
 }
38329
 if (deleteAllowed) {
   assign(actions, {
     'delete': {
       group: 'edit',
       className: 'bpmn-icon-trash',
       title: translate('Remove'),
       action: {
         click: removeElement
       }
     }
   });
 }
38342
 return actions;
};
38345
38346
// helpers /////////
38348
function isEventType(eventBo, type, definition) {
38350
 var isType = eventBo.$instanceOf(type);
 var isDefinition = false;
38353
 var definitions = eventBo.eventDefinitions || [];
 forEach$2(definitions, function(def) {
   if (def.$type === definition) {
     isDefinition = true;
   }
 });
38360
 return isType && isDefinition;
}
38363
var ContextPadModule = {
 __depends__: [
   DirectEditingModule,
   ContextPadModule$1,
   SelectionModule,
   ConnectModule,
   CreateModule,
   PopupMenuModule
 ],
 __init__: [ 'contextPadProvider' ],
 contextPadProvider: [ 'type', ContextPadProvider ]
};
38376
var AXIS_DIMENSIONS = {
 horizontal: [ 'x', 'width' ],
 vertical: [ 'y', 'height' ]
};
38381
var THRESHOLD = 5;
38383
38384
/**
* Groups and filters elements and then trigger even distribution.
*/
function DistributeElements$1(modeling) {
 this._modeling = modeling;
38390
 this._filters = [];
38392
 // register filter for filtering big elements
 this.registerFilter(function(elements, axis, dimension) {
   var elementsSize = 0,
       numOfShapes = 0,
       avgDimension;
38398
   forEach$2(elements, function(element) {
     if (element.waypoints || element.labelTarget) {
       return;
     }
38403
     elementsSize += element[dimension];
38405
     numOfShapes += 1;
   });
38408
   avgDimension = Math.round(elementsSize / numOfShapes);
38410
   return filter(elements, function(element) {
     return element[dimension] < (avgDimension + 50);
   });
 });
38415
}
38417
DistributeElements$1.$inject = [ 'modeling' ];
38419
38420
/**
* Registers filter functions that allow external parties to filter
* out certain elements.
*
* @param  {Function} filterFn
*/
DistributeElements$1.prototype.registerFilter = function(filterFn) {
 if (typeof filterFn !== 'function') {
   throw new Error('the filter has to be a function');
 }
38431
 this._filters.push(filterFn);
};
38434
/**
* Distributes the elements with a given orientation
*
* @param  {Array} elements
* @param  {string} orientation
*/
DistributeElements$1.prototype.trigger = function(elements, orientation) {
 var modeling = this._modeling;
38443
 var groups,
     distributableElements;
38446
 if (elements.length < 3) {
   return;
 }
38450
 this._setOrientation(orientation);
38452
 distributableElements = this._filterElements(elements);
38454
 groups = this._createGroups(distributableElements);
38456
 // nothing to distribute
 if (groups.length <= 2) {
   return;
 }
38461
 modeling.distributeElements(groups, this._axis, this._dimension);
38463
 return groups;
};
38466
/**
* Filters the elements with provided filters by external parties
*
* @param  {Array[Elements]} elements
*
* @return {Array[Elements]}
*/
DistributeElements$1.prototype._filterElements = function(elements) {
 var filters = this._filters,
     axis = this._axis,
     dimension = this._dimension,
     distributableElements = [].concat(elements);
38479
 if (!filters.length) {
   return elements;
 }
38483
 forEach$2(filters, function(filterFn) {
   distributableElements = filterFn(distributableElements, axis, dimension);
 });
38487
 return distributableElements;
};
38490
38491
/**
* Create range (min, max) groups. Also tries to group elements
* together that share the same range.
*
* @example
* 	var distributableElements = [
* 		{
* 			range: {
* 				min: 100,
* 				max: 200
* 			},
* 			elements: [ { id: 'shape1', .. }]
* 		}
* 	]
*
* @param  {Array} elements
*
* @return {Array[Objects]}
*/
DistributeElements$1.prototype._createGroups = function(elements) {
 var rangeGroups = [],
     self = this,
     axis = this._axis,
     dimension = this._dimension;
38516
 if (!axis) {
   throw new Error('must have a defined "axis" and "dimension"');
 }
38520
 // sort by 'left->right' or 'top->bottom'
 var sortedElements = sortBy(elements, axis);
38523
 forEach$2(sortedElements, function(element, idx) {
   var elementRange = self._findRange(element, axis, dimension),
       range;
38527
   var previous = rangeGroups[rangeGroups.length - 1];
38529
   if (previous && self._hasIntersection(previous.range, elementRange)) {
     rangeGroups[rangeGroups.length - 1].elements.push(element);
   } else {
     range = { range: elementRange, elements: [ element ] };
38534
     rangeGroups.push(range);
   }
 });
38538
 return rangeGroups;
};
38541
38542
/**
* Maps a direction to the according axis and dimension
*
* @param  {string} direction 'horizontal' or 'vertical'
*/
DistributeElements$1.prototype._setOrientation = function(direction) {
 var orientation = AXIS_DIMENSIONS[direction];
38550
 this._axis = orientation[0];
 this._dimension = orientation[1];
};
38554
38555
/**
* Checks if the two ranges intercept each other
*
* @param  {Object} rangeA {min, max}
* @param  {Object} rangeB {min, max}
*
* @return {boolean}
*/
DistributeElements$1.prototype._hasIntersection = function(rangeA, rangeB) {
 return Math.max(rangeA.min, rangeA.max) >= Math.min(rangeB.min, rangeB.max) &&
        Math.min(rangeA.min, rangeA.max) <= Math.max(rangeB.min, rangeB.max);
};
38568
38569
/**
* Returns the min and max values for an element
*
* @param  {Bounds} element
* @param  {string} axis
* @param  {string} dimension
*
* @return {{ min: number, max: number }}
*/
DistributeElements$1.prototype._findRange = function(element) {
 var axis = element[this._axis],
     dimension = element[this._dimension];
38582
 return {
   min: axis + THRESHOLD,
   max: axis + dimension - THRESHOLD
 };
};
38588
var DistributeElementsModule$1 = {
 __init__: [ 'distributeElements' ],
 distributeElements: [ 'type', DistributeElements$1 ]
};
38593
/**
* Registers element exclude filters for elements that
* currently do not support distribution.
*/
function BpmnDistributeElements(distributeElements) {
38599
 distributeElements.registerFilter(function(elements) {
   return filter(elements, function(element) {
     var cannotDistribute = isAny(element, [
       'bpmn:Association',
       'bpmn:BoundaryEvent',
       'bpmn:DataInputAssociation',
       'bpmn:DataOutputAssociation',
       'bpmn:Lane',
       'bpmn:MessageFlow',
       'bpmn:Participant',
       'bpmn:SequenceFlow',
       'bpmn:TextAnnotation'
     ]);
38613
     return !(element.labelTarget || cannotDistribute);
   });
 });
}
38618
BpmnDistributeElements.$inject = [ 'distributeElements' ];
38620
var DistributeElementsModule = {
 __depends__: [
   DistributeElementsModule$1
 ],
 __init__: [ 'bpmnDistributeElements' ],
 bpmnDistributeElements: [ 'type', BpmnDistributeElements ]
};
38628
var NOT_REGISTERED_ERROR = 'is not a registered action',
   IS_REGISTERED_ERROR = 'is already registered';
38631
38632
/**
* An interface that provides access to modeling actions by decoupling
* the one who requests the action to be triggered and the trigger itself.
*
* It's possible to add new actions by registering them with ´registerAction´
* and likewise unregister existing ones with ´unregisterAction´.
*
*
* ## Life-Cycle and configuration
*
* The editor actions will wait for diagram initialization before
* registering default actions _and_ firing an `editorActions.init` event.
*
* Interested parties may listen to the `editorActions.init` event with
* low priority to check, which actions got registered. Other components
* may use the event to register their own actions via `registerAction`.
*
* @param {EventBus} eventBus
* @param {Injector} injector
*/
function EditorActions(eventBus, injector) {
38654
 // initialize actions
 this._actions = {};
38657
 var self = this;
38659
 eventBus.on('diagram.init', function() {
38661
   // all diagram modules got loaded; check which ones
   // are available and register the respective default actions
   self._registerDefaultActions(injector);
38665
   // ask interested parties to register available editor
   // actions on diagram initialization
   eventBus.fire('editorActions.init', {
     editorActions: self
   });
 });
38672
}
38674
EditorActions.$inject = [
 'eventBus',
 'injector'
];
38679
/**
* Register default actions.
*
* @param {Injector} injector
*/
EditorActions.prototype._registerDefaultActions = function(injector) {
38686
 // (1) retrieve optional components to integrate with
38688
 var commandStack = injector.get('commandStack', false);
 var modeling = injector.get('modeling', false);
 var selection = injector.get('selection', false);
 var zoomScroll = injector.get('zoomScroll', false);
 var copyPaste = injector.get('copyPaste', false);
 var canvas = injector.get('canvas', false);
 var rules = injector.get('rules', false);
 var keyboardMove = injector.get('keyboardMove', false);
 var keyboardMoveSelection = injector.get('keyboardMoveSelection', false);
38698
 // (2) check components and register actions
38700
 if (commandStack) {
   this.register('undo', function() {
     commandStack.undo();
   });
38705
   this.register('redo', function() {
     commandStack.redo();
   });
 }
38710
 if (copyPaste && selection) {
   this.register('copy', function() {
     var selectedElements = selection.get();
38714
     copyPaste.copy(selectedElements);
   });
 }
38718
 if (copyPaste) {
   this.register('paste', function() {
     copyPaste.paste();
   });
 }
38724
 if (zoomScroll) {
   this.register('stepZoom', function(opts) {
     zoomScroll.stepZoom(opts.value);
   });
 }
38730
 if (canvas) {
   this.register('zoom', function(opts) {
     canvas.zoom(opts.value);
   });
 }
38736
 if (modeling && selection && rules) {
   this.register('removeSelection', function() {
38739
     var selectedElements = selection.get();
38741
     if (!selectedElements.length) {
       return;
     }
38745
     var allowed = rules.allowed('elements.delete', { elements: selectedElements }),
         removableElements;
38748
     if (allowed === false) {
       return;
     }
     else if (isArray$4(allowed)) {
       removableElements = allowed;
     }
     else {
       removableElements = selectedElements;
     }
38758
     if (removableElements.length) {
       modeling.removeElements(removableElements.slice());
     }
   });
 }
38764
 if (keyboardMove) {
   this.register('moveCanvas', function(opts) {
     keyboardMove.moveCanvas(opts);
   });
 }
38770
 if (keyboardMoveSelection) {
   this.register('moveSelection', function(opts) {
     keyboardMoveSelection.moveSelection(opts.direction, opts.accelerated);
   });
 }
38776
};
38778
38779
/**
* Triggers a registered action
*
* @param  {string} action
* @param  {Object} opts
*
* @return {Unknown} Returns what the registered listener returns
*/
EditorActions.prototype.trigger = function(action, opts) {
 if (!this._actions[action]) {
   throw error(action, NOT_REGISTERED_ERROR);
 }
38792
 return this._actions[action](opts);
};
38795
38796
/**
* Registers a collections of actions.
* The key of the object will be the name of the action.
*
* @example
* ´´´
* var actions = {
*   spaceTool: function() {
*     spaceTool.activateSelection();
*   },
*   lassoTool: function() {
*     lassoTool.activateSelection();
*   }
* ];
*
* editorActions.register(actions);
*
* editorActions.isRegistered('spaceTool'); // true
* ´´´
*
* @param  {Object} actions
*/
EditorActions.prototype.register = function(actions, listener) {
 var self = this;
38821
 if (typeof actions === 'string') {
   return this._registerAction(actions, listener);
 }
38825
 forEach$2(actions, function(listener, action) {
   self._registerAction(action, listener);
 });
};
38830
/**
* Registers a listener to an action key
*
* @param  {string} action
* @param  {Function} listener
*/
EditorActions.prototype._registerAction = function(action, listener) {
 if (this.isRegistered(action)) {
   throw error(action, IS_REGISTERED_ERROR);
 }
38841
 this._actions[action] = listener;
};
38844
/**
* Unregister an existing action
*
* @param {string} action
*/
EditorActions.prototype.unregister = function(action) {
 if (!this.isRegistered(action)) {
   throw error(action, NOT_REGISTERED_ERROR);
 }
38854
 this._actions[action] = undefined;
};
38857
/**
* Returns the number of actions that are currently registered
*
* @return {number}
*/
EditorActions.prototype.getActions = function() {
 return Object.keys(this._actions);
};
38866
/**
* Checks wether the given action is registered
*
* @param {string} action
*
* @return {boolean}
*/
EditorActions.prototype.isRegistered = function(action) {
 return !!this._actions[action];
};
38877
38878
function error(action, message) {
 return new Error(action + ' ' + message);
}
38882
var EditorActionsModule$1 = {
 __init__: [ 'editorActions' ],
 editorActions: [ 'type', EditorActions ]
};
38887
/**
* Registers and executes BPMN specific editor actions.
*
* @param {Injector} injector
*/
function BpmnEditorActions(injector) {
 injector.invoke(EditorActions, this);
}
38896
inherits$1(BpmnEditorActions, EditorActions);
38898
BpmnEditorActions.$inject = [
 'injector'
];
38902
/**
* Register default actions.
*
* @param {Injector} injector
*/
BpmnEditorActions.prototype._registerDefaultActions = function(injector) {
38909
 // (0) invoke super method
38911
 EditorActions.prototype._registerDefaultActions.call(this, injector);
38913
 // (1) retrieve optional components to integrate with
38915
 var canvas = injector.get('canvas', false);
 var elementRegistry = injector.get('elementRegistry', false);
 var selection = injector.get('selection', false);
 var spaceTool = injector.get('spaceTool', false);
 var lassoTool = injector.get('lassoTool', false);
 var handTool = injector.get('handTool', false);
 var globalConnect = injector.get('globalConnect', false);
 var distributeElements = injector.get('distributeElements', false);
 var alignElements = injector.get('alignElements', false);
 var directEditing = injector.get('directEditing', false);
 var searchPad = injector.get('searchPad', false);
 var modeling = injector.get('modeling', false);
38928
 // (2) check components and register actions
38930
 if (canvas && elementRegistry && selection) {
   this._registerAction('selectElements', function() {
38933
     // select all elements except for the invisible
     // root element
     var rootElement = canvas.getRootElement();
38937
     var elements = elementRegistry.filter(function(element) {
       return element !== rootElement;
     });
38941
     selection.select(elements);
38943
     return elements;
   });
 }
38947
 if (spaceTool) {
   this._registerAction('spaceTool', function() {
     spaceTool.toggle();
   });
 }
38953
 if (lassoTool) {
   this._registerAction('lassoTool', function() {
     lassoTool.toggle();
   });
 }
38959
 if (handTool) {
   this._registerAction('handTool', function() {
     handTool.toggle();
   });
 }
38965
 if (globalConnect) {
   this._registerAction('globalConnectTool', function() {
     globalConnect.toggle();
   });
 }
38971
 if (selection && distributeElements) {
   this._registerAction('distributeElements', function(opts) {
     var currentSelection = selection.get(),
         type = opts.type;
38976
     if (currentSelection.length) {
       distributeElements.trigger(currentSelection, type);
     }
   });
 }
38982
 if (selection && alignElements) {
   this._registerAction('alignElements', function(opts) {
     var currentSelection = selection.get(),
         aligneableElements = [],
         type = opts.type;
38988
     if (currentSelection.length) {
       aligneableElements = filter(currentSelection, function(element) {
         return !is$1(element, 'bpmn:Lane');
       });
38993
       alignElements.trigger(aligneableElements, type);
     }
   });
 }
38998
 if (selection && modeling) {
   this._registerAction('setColor', function(opts) {
     var currentSelection = selection.get();
39002
     if (currentSelection.length) {
       modeling.setColor(currentSelection, opts);
     }
   });
 }
39008
 if (selection && directEditing) {
   this._registerAction('directEditing', function() {
     var currentSelection = selection.get();
39012
     if (currentSelection.length) {
       directEditing.activate(currentSelection[0]);
     }
   });
 }
39018
 if (searchPad) {
   this._registerAction('find', function() {
     searchPad.toggle();
   });
 }
39024
 if (canvas && modeling) {
   this._registerAction('moveToOrigin', function() {
     var rootElement = canvas.getRootElement(),
         boundingBox,
         elements;
39030
     if (is$1(rootElement, 'bpmn:Collaboration')) {
       elements = elementRegistry.filter(function(element) {
         return is$1(element.parent, 'bpmn:Collaboration');
       });
     } else {
       elements = elementRegistry.filter(function(element) {
         return element !== rootElement && !is$1(element.parent, 'bpmn:SubProcess');
       });
     }
39040
     boundingBox = getBBox(elements);
39042
     modeling.moveElements(
       elements,
       { x: -boundingBox.x, y: -boundingBox.y },
       rootElement
     );
   });
 }
39050
};
39052
var EditorActionsModule = {
 __depends__: [
   EditorActionsModule$1
 ],
 editorActions: [ 'type', BpmnEditorActions ]
};
39059
function BpmnGridSnapping(eventBus) {
 eventBus.on([
   'create.init',
   'shape.move.init'
 ], function(event) {
   var context = event.context,
       shape = event.shape;
39067
   if (isAny(shape, [
     'bpmn:Participant',
     'bpmn:SubProcess',
     'bpmn:TextAnnotation'
   ])) {
     if (!context.gridSnappingContext) {
       context.gridSnappingContext = {};
     }
39076
     context.gridSnappingContext.snapLocation = 'top-left';
   }
 });
}
39081
BpmnGridSnapping.$inject = [ 'eventBus' ];
39083
var SPACING = 10;
39085
function quantize(value, quantum, fn) {
 if (!fn) {
   fn = 'round';
 }
39090
 return Math[ fn ](value / quantum) * quantum;
}
39093
var LOWER_PRIORITY = 1200;
var LOW_PRIORITY$f = 800;
39096
/**
* Basic grid snapping that covers connecting, creating, moving, resizing shapes, moving bendpoints
* and connection segments.
*/
function GridSnapping(elementRegistry, eventBus, config) {
39102
 var active = !config || config.active !== false;
39104
 this._eventBus = eventBus;
39106
 var self = this;
39108
 eventBus.on('diagram.init', LOW_PRIORITY$f, function() {
   self.setActive(active);
 });
39112
 eventBus.on([
   'create.move',
   'create.end',
   'bendpoint.move.move',
   'bendpoint.move.end',
   'connect.move',
   'connect.end',
   'connectionSegment.move.move',
   'connectionSegment.move.end',
   'resize.move',
   'resize.end',
   'shape.move.move',
   'shape.move.end'
 ], LOWER_PRIORITY, function(event) {
   var originalEvent = event.originalEvent;
39128
   if (!self.active || (originalEvent && isCmd(originalEvent))) {
     return;
   }
39132
   var context = event.context,
       gridSnappingContext = context.gridSnappingContext;
39135
   if (!gridSnappingContext) {
     gridSnappingContext = context.gridSnappingContext = {};
   }
39139
   [ 'x', 'y' ].forEach(function(axis) {
     var options = {};
39142
     // allow snapping with offset
     var snapOffset = getSnapOffset(event, axis, elementRegistry);
39145
     if (snapOffset) {
       options.offset = snapOffset;
     }
39149
     // allow snapping with min and max
     var snapConstraints = getSnapConstraints(event, axis);
39152
     if (snapConstraints) {
       assign(options, snapConstraints);
     }
39156
     if (!isSnapped(event, axis)) {
       self.snapEvent(event, axis, options);
     }
   });
 });
}
39163
/**
* Snap an events x or y with optional min, max and offset.
*
* @param {Object} event
* @param {string} axis
* @param {number} [options.min]
* @param {number} [options.max]
* @param {number} [options.offset]
*/
GridSnapping.prototype.snapEvent = function(event, axis, options) {
 var snappedValue = this.snapValue(event[ axis ], options);
39175
 setSnapped(event, axis, snappedValue);
};
39178
/**
* Expose grid spacing for third parties (i.e. extensions).
*
* @return {number} spacing of grid dots
*/
GridSnapping.prototype.getGridSpacing = function() {
 return SPACING;
};
39187
/**
* Snap value with optional min, max and offset.
*
* @param {number} value
* @param {Object} options
* @param {number} [options.min]
* @param {number} [options.max]
* @param {number} [options.offset]
*/
GridSnapping.prototype.snapValue = function(value, options) {
 var offset = 0;
39199
 if (options && options.offset) {
   offset = options.offset;
 }
39203
 value += offset;
39205
 value = quantize(value, SPACING);
39207
 var min, max;
39209
 if (options && options.min) {
   min = options.min;
39212
   if (isNumber(min)) {
     min = quantize(min + offset, SPACING, 'ceil');
39215
     value = Math.max(value, min);
   }
 }
39219
 if (options && options.max) {
   max = options.max;
39222
   if (isNumber(max)) {
     max = quantize(max + offset, SPACING, 'floor');
39225
     value = Math.min(value, max);
   }
 }
39229
 value -= offset;
39231
 return value;
};
39234
GridSnapping.prototype.isActive = function() {
 return this.active;
};
39238
GridSnapping.prototype.setActive = function(active) {
 this.active = active;
39241
 this._eventBus.fire('gridSnapping.toggle', { active: active });
};
39244
GridSnapping.prototype.toggleActive = function() {
 this.setActive(!this.active);
};
39248
GridSnapping.$inject = [
 'elementRegistry',
 'eventBus',
 'config.gridSnapping'
];
39254
// helpers //////////
39256
/**
* Get minimum and maximum snap constraints.
* Constraints are cached.
*
* @param {Object} event
* @param {Object} event.context
* @param {string} axis
*
* @returns {boolean|Object}
*/
function getSnapConstraints(event, axis) {
 var context = event.context,
     createConstraints = context.createConstraints,
     resizeConstraints = context.resizeConstraints || {},
     gridSnappingContext = context.gridSnappingContext,
     snapConstraints = gridSnappingContext.snapConstraints;
39273
 // cache snap constraints
 if (snapConstraints && snapConstraints[ axis ]) {
   return snapConstraints[ axis ];
 }
39278
 if (!snapConstraints) {
   snapConstraints = gridSnappingContext.snapConstraints = {};
 }
39282
 if (!snapConstraints[ axis ]) {
   snapConstraints[ axis ] = {};
 }
39286
 var direction = context.direction;
39288
 // create
 if (createConstraints) {
   if (isHorizontal$3(axis)) {
     snapConstraints.x.min = createConstraints.left;
     snapConstraints.x.max = createConstraints.right;
   } else {
     snapConstraints.y.min = createConstraints.top;
     snapConstraints.y.max = createConstraints.bottom;
   }
 }
39299
 // resize
 var minResizeConstraints = resizeConstraints.min,
     maxResizeConstraints = resizeConstraints.max;
39303
 if (minResizeConstraints) {
   if (isHorizontal$3(axis)) {
39306
     if (isWest(direction)) {
       snapConstraints.x.max = minResizeConstraints.left;
     } else {
       snapConstraints.x.min = minResizeConstraints.right;
     }
39312
   } else {
39314
     if (isNorth(direction)) {
       snapConstraints.y.max = minResizeConstraints.top;
     } else {
       snapConstraints.y.min = minResizeConstraints.bottom;
     }
39320
   }
 }
39323
 if (maxResizeConstraints) {
   if (isHorizontal$3(axis)) {
39326
     if (isWest(direction)) {
       snapConstraints.x.min = maxResizeConstraints.left;
     } else {
       snapConstraints.x.max = maxResizeConstraints.right;
     }
39332
   } else {
39334
     if (isNorth(direction)) {
       snapConstraints.y.min = maxResizeConstraints.top;
     } else {
       snapConstraints.y.max = maxResizeConstraints.bottom;
     }
39340
   }
 }
39343
 return snapConstraints[ axis ];
}
39346
/**
* Get snap offset.
* Offset is cached.
*
* @param {Object} event
* @param {string} axis
* @param {ElementRegistry} elementRegistry
*
* @returns {number}
*/
function getSnapOffset(event, axis, elementRegistry) {
 var context = event.context,
     shape = event.shape,
     gridSnappingContext = context.gridSnappingContext,
     snapLocation = gridSnappingContext.snapLocation,
     snapOffset = gridSnappingContext.snapOffset;
39363
 // cache snap offset
 if (snapOffset && isNumber(snapOffset[ axis ])) {
   return snapOffset[ axis ];
 }
39368
 if (!snapOffset) {
   snapOffset = gridSnappingContext.snapOffset = {};
 }
39372
 if (!isNumber(snapOffset[ axis ])) {
   snapOffset[ axis ] = 0;
 }
39376
 if (!shape) {
   return snapOffset[ axis ];
 }
39380
 if (!elementRegistry.get(shape.id)) {
39382
   if (isHorizontal$3(axis)) {
     snapOffset[ axis ] += shape[ axis ] + shape.width / 2;
   } else {
     snapOffset[ axis ] += shape[ axis ] + shape.height / 2;
   }
 }
39389
 if (!snapLocation) {
   return snapOffset[ axis ];
 }
39393
 if (axis === 'x') {
   if (/left/.test(snapLocation)) {
     snapOffset[ axis ] -= shape.width / 2;
   } else if (/right/.test(snapLocation)) {
     snapOffset[ axis ] += shape.width / 2;
   }
 } else {
   if (/top/.test(snapLocation)) {
     snapOffset[ axis ] -= shape.height / 2;
   } else if (/bottom/.test(snapLocation)) {
     snapOffset[ axis ] += shape.height / 2;
   }
 }
39407
 return snapOffset[ axis ];
}
39410
function isHorizontal$3(axis) {
 return axis === 'x';
}
39414
function isNorth(direction) {
 return direction.indexOf('n') !== -1;
}
39418
function isWest(direction) {
 return direction.indexOf('w') !== -1;
}
39422
/**
* Integrates resizing with grid snapping.
*/
function ResizeBehavior$1(eventBus, gridSnapping) {
 CommandInterceptor.call(this, eventBus);
39428
 this._gridSnapping = gridSnapping;
39430
 var self = this;
39432
 this.preExecute('shape.resize', function(event) {
   var context = event.context,
       hints = context.hints || {},
       autoResize = hints.autoResize;
39437
   if (!autoResize) {
     return;
   }
39441
   var shape = context.shape,
       newBounds = context.newBounds;
39444
   if (isString(autoResize)) {
     context.newBounds = self.snapComplex(newBounds, autoResize);
   } else {
     context.newBounds = self.snapSimple(shape, newBounds);
   }
 });
}
39452
ResizeBehavior$1.$inject = [
 'eventBus',
 'gridSnapping',
 'modeling'
];
39458
inherits$1(ResizeBehavior$1, CommandInterceptor);
39460
/**
* Snap width and height in relation to center.
*
* @param {djs.model.shape} shape
* @param {Bounds} newBounds
*
* @returns {Bounds} Snapped bounds.
*/
ResizeBehavior$1.prototype.snapSimple = function(shape, newBounds) {
 var gridSnapping = this._gridSnapping;
39471
 newBounds.width = gridSnapping.snapValue(newBounds.width, {
   min: newBounds.width
 });
39475
 newBounds.height = gridSnapping.snapValue(newBounds.height, {
   min: newBounds.height
 });
39479
 newBounds.x = shape.x + (shape.width / 2) - (newBounds.width / 2);
 newBounds.y = shape.y + (shape.height / 2) - (newBounds.height / 2);
39482
 return newBounds;
};
39485
/**
* Snap x, y, width and height according to given directions.
*
* @param {Bounds} newBounds
* @param {string} directions - Directions as {n|w|s|e}.
*
* @returns {Bounds} Snapped bounds.
*/
ResizeBehavior$1.prototype.snapComplex = function(newBounds, directions) {
 if (/w|e/.test(directions)) {
   newBounds = this.snapHorizontally(newBounds, directions);
 }
39498
 if (/n|s/.test(directions)) {
   newBounds = this.snapVertically(newBounds, directions);
 }
39502
 return newBounds;
};
39505
/**
* Snap in one or both directions horizontally.
*
* @param {Bounds} newBounds
* @param {string} directions - Directions as {n|w|s|e}.
*
* @returns {Bounds} Snapped bounds.
*/
ResizeBehavior$1.prototype.snapHorizontally = function(newBounds, directions) {
 var gridSnapping = this._gridSnapping,
     west = /w/.test(directions),
     east = /e/.test(directions);
39518
 var snappedNewBounds = {};
39520
 snappedNewBounds.width = gridSnapping.snapValue(newBounds.width, {
   min: newBounds.width
 });
39524
 if (east) {
39526
   // handle <we>
   if (west) {
     snappedNewBounds.x = gridSnapping.snapValue(newBounds.x, {
       max: newBounds.x
     });
39532
     snappedNewBounds.width += gridSnapping.snapValue(newBounds.x - snappedNewBounds.x, {
       min: newBounds.x - snappedNewBounds.x
     });
   }
39537
   // handle <e>
   else {
     newBounds.x = newBounds.x + newBounds.width - snappedNewBounds.width;
   }
 }
39543
 // assign snapped x and width
 assign(newBounds, snappedNewBounds);
39546
 return newBounds;
};
39549
/**
* Snap in one or both directions vertically.
*
* @param {Bounds} newBounds
* @param {string} directions - Directions as {n|w|s|e}.
*
* @returns {Bounds} Snapped bounds.
*/
ResizeBehavior$1.prototype.snapVertically = function(newBounds, directions) {
 var gridSnapping = this._gridSnapping,
     north = /n/.test(directions),
     south = /s/.test(directions);
39562
 var snappedNewBounds = {};
39564
 snappedNewBounds.height = gridSnapping.snapValue(newBounds.height, {
   min: newBounds.height
 });
39568
 if (north) {
39570
   // handle <ns>
   if (south) {
     snappedNewBounds.y = gridSnapping.snapValue(newBounds.y, {
       max: newBounds.y
     });
39576
     snappedNewBounds.height += gridSnapping.snapValue(newBounds.y - snappedNewBounds.y, {
       min: newBounds.y - snappedNewBounds.y
     });
   }
39581
   // handle <n>
   else {
     newBounds.y = newBounds.y + newBounds.height - snappedNewBounds.height;
   }
 }
39587
 // assign snapped y and height
 assign(newBounds, snappedNewBounds);
39590
 return newBounds;
};
39593
var HIGH_PRIORITY$g = 2000;
39595
/**
* Integrates space tool with grid snapping.
*/
function SpaceToolBehavior$1(eventBus, gridSnapping) {
 eventBus.on([
   'spaceTool.move',
   'spaceTool.end'
 ], HIGH_PRIORITY$g, function(event) {
   var context = event.context;
39605
   if (!context.initialized) {
     return;
   }
39609
   var axis = context.axis;
39611
   var snapped;
39613
   if (axis === 'x') {
39615
     // snap delta x to multiple of 10
     snapped = gridSnapping.snapValue(event.dx);
39618
     event.x = event.x + snapped - event.dx;
     event.dx = snapped;
   } else {
39622
     // snap delta y to multiple of 10
     snapped = gridSnapping.snapValue(event.dy);
39625
     event.y = event.y + snapped - event.dy;
     event.dy = snapped;
   }
 });
}
39631
SpaceToolBehavior$1.$inject = [
 'eventBus',
 'gridSnapping'
];
39636
var GridSnappingBehaviorModule$1 = {
 __init__: [
   'gridSnappingResizeBehavior',
   'gridSnappingSpaceToolBehavior'
 ],
 gridSnappingResizeBehavior: [ 'type', ResizeBehavior$1 ],
 gridSnappingSpaceToolBehavior: [ 'type', SpaceToolBehavior$1 ]
};
39645
var GridSnappingModule$1 = {
 __depends__: [ GridSnappingBehaviorModule$1 ],
 __init__: [ 'gridSnapping' ],
 gridSnapping: [ 'type', GridSnapping ]
};
39651
var HIGH_PRIORITY$f = 2000;
39653
39654
function AutoPlaceBehavior(eventBus, gridSnapping) {
 eventBus.on('autoPlace', HIGH_PRIORITY$f, function(context) {
   var source = context.source,
       sourceMid = getMid(source),
       shape = context.shape;
39660
   var position = getNewShapePosition(source, shape);
39662
   [ 'x', 'y' ].forEach(function(axis) {
     var options = {};
39665
     // do not snap if x/y equal
     if (position[ axis ] === sourceMid[ axis ]) {
       return;
     }
39670
     if (position[ axis ] > sourceMid[ axis ]) {
       options.min = position[ axis ];
     } else {
       options.max = position[ axis ];
     }
39676
     if (is$1(shape, 'bpmn:TextAnnotation')) {
39678
       if (isHorizontal$2(axis)) {
         options.offset = -shape.width / 2;
       } else {
         options.offset = -shape.height / 2;
       }
39684
     }
39686
     position[ axis ] = gridSnapping.snapValue(position[ axis ], options);
39688
   });
39690
   // must be returned to be considered by auto place
   return position;
 });
}
39695
AutoPlaceBehavior.$inject = [
 'eventBus',
 'gridSnapping'
];
39700
// helpers //////////
39702
function isHorizontal$2(axis) {
 return axis === 'x';
}
39706
var HIGHER_PRIORITY$4 = 1750;
39708
39709
function CreateParticipantBehavior$1(canvas, eventBus, gridSnapping) {
 eventBus.on([
   'create.start',
   'shape.move.start'
 ], HIGHER_PRIORITY$4, function(event) {
   var context = event.context,
       shape = context.shape,
       rootElement = canvas.getRootElement();
39718
   if (!is$1(shape, 'bpmn:Participant') ||
     !is$1(rootElement, 'bpmn:Process') ||
     !rootElement.children.length) {
     return;
   }
39724
   var createConstraints = context.createConstraints;
39726
   if (!createConstraints) {
     return;
   }
39730
   shape.width = gridSnapping.snapValue(shape.width, { min: shape.width });
   shape.height = gridSnapping.snapValue(shape.height, { min: shape.height });
 });
}
39735
CreateParticipantBehavior$1.$inject = [
 'canvas',
 'eventBus',
 'gridSnapping'
];
39741
var HIGH_PRIORITY$e = 3000;
39743
39744
/**
* Snaps connections with Manhattan layout.
*/
function LayoutConnectionBehavior(eventBus, gridSnapping, modeling) {
 CommandInterceptor.call(this, eventBus);
39750
 this._gridSnapping = gridSnapping;
39752
 var self = this;
39754
 this.postExecuted([
   'connection.create',
   'connection.layout'
 ], HIGH_PRIORITY$e, function(event) {
   var context = event.context,
       connection = context.connection,
       hints = context.hints || {},
       waypoints = connection.waypoints;
39763
   if (hints.connectionStart || hints.connectionEnd || hints.createElementsBehavior === false) {
     return;
   }
39767
   if (!hasMiddleSegments(waypoints)) {
     return;
   }
39771
   modeling.updateWaypoints(connection, self.snapMiddleSegments(waypoints));
 });
}
39775
LayoutConnectionBehavior.$inject = [
 'eventBus',
 'gridSnapping',
 'modeling'
];
39781
inherits$1(LayoutConnectionBehavior, CommandInterceptor);
39783
/**
* Snap middle segments of a given connection.
*
* @param {Array<Point>} waypoints
*
* @returns {Array<Point>}
*/
LayoutConnectionBehavior.prototype.snapMiddleSegments = function(waypoints) {
 var gridSnapping = this._gridSnapping,
     snapped;
39794
 waypoints = waypoints.slice();
39796
 for (var i = 1; i < waypoints.length - 2; i++) {
39798
   snapped = snapSegment(gridSnapping, waypoints[i], waypoints[i + 1]);
39800
   waypoints[i] = snapped[0];
   waypoints[i + 1] = snapped[1];
 }
39804
 return waypoints;
};
39807
39808
// helpers //////////
39810
/**
* Check whether a connection has a middle segments.
*
* @param {Array} waypoints
*
* @returns {boolean}
*/
function hasMiddleSegments(waypoints) {
 return waypoints.length > 3;
}
39821
/**
* Check whether an alignment is horizontal.
*
* @param {string} aligned
*
* @returns {boolean}
*/
function horizontallyAligned(aligned) {
 return aligned === 'h';
}
39832
/**
* Check whether an alignment is vertical.
*
* @param {string} aligned
*
* @returns {boolean}
*/
function verticallyAligned(aligned) {
 return aligned === 'v';
}
39843
/**
* Get middle segments from a given connection.
*
* @param {Array} waypoints
*
* @returns {Array}
*/
function snapSegment(gridSnapping, segmentStart, segmentEnd) {
39852
 var aligned = pointsAligned(segmentStart, segmentEnd);
39854
 var snapped = {};
39856
 if (horizontallyAligned(aligned)) {
39858
   // snap horizontally
   snapped.y = gridSnapping.snapValue(segmentStart.y);
 }
39862
 if (verticallyAligned(aligned)) {
39864
   // snap vertically
   snapped.x = gridSnapping.snapValue(segmentStart.x);
 }
39868
 if ('x' in snapped || 'y' in snapped) {
   segmentStart = assign({}, segmentStart, snapped);
   segmentEnd = assign({}, segmentEnd, snapped);
 }
39873
 return [ segmentStart, segmentEnd ];
}
39876
var GridSnappingBehaviorModule = {
 __init__: [
   'gridSnappingAutoPlaceBehavior',
   'gridSnappingCreateParticipantBehavior',
   'gridSnappingLayoutConnectionBehavior',
 ],
 gridSnappingAutoPlaceBehavior: [ 'type', AutoPlaceBehavior ],
 gridSnappingCreateParticipantBehavior: [ 'type', CreateParticipantBehavior$1 ],
 gridSnappingLayoutConnectionBehavior: [ 'type', LayoutConnectionBehavior ]
};
39887
var GridSnappingModule = {
 __depends__: [
   GridSnappingModule$1,
   GridSnappingBehaviorModule
 ],
 __init__: [ 'bpmnGridSnapping' ],
 bpmnGridSnapping: [ 'type', BpmnGridSnapping ]
};
39896
var LABEL_WIDTH = 30,
   LABEL_HEIGHT = 30;
39899
39900
/**
* BPMN-specific hit zones and interaction fixes.
*
* @param {EventBus} eventBus
* @param {InteractionEvents} interactionEvents
*/
function BpmnInteractionEvents(eventBus, interactionEvents) {
39908
 this._interactionEvents = interactionEvents;
39910
 var self = this;
39912
 eventBus.on([
   'interactionEvents.createHit',
   'interactionEvents.updateHit'
 ], function(context) {
   var element = context.element,
       gfx = context.gfx;
39919
   if (is$1(element, 'bpmn:Lane')) {
     return self.createParticipantHit(element, gfx);
   } else
39923
   if (is$1(element, 'bpmn:Participant')) {
     if (isExpanded(element)) {
       return self.createParticipantHit(element, gfx);
     } else {
       return self.createDefaultHit(element, gfx);
     }
   } else
39931
   if (is$1(element, 'bpmn:SubProcess')) {
     if (isExpanded(element)) {
       return self.createSubProcessHit(element, gfx);
     } else {
       return self.createDefaultHit(element, gfx);
     }
   }
 });
39940
}
39942
BpmnInteractionEvents.$inject = [
 'eventBus',
 'interactionEvents'
];
39947
39948
BpmnInteractionEvents.prototype.createDefaultHit = function(element, gfx) {
 this._interactionEvents.removeHits(gfx);
39951
 this._interactionEvents.createDefaultHit(element, gfx);
39953
 // indicate that we created a hit
 return true;
};
39957
BpmnInteractionEvents.prototype.createParticipantHit = function(element, gfx) {
39959
 // remove existing hits
 this._interactionEvents.removeHits(gfx);
39962
 // add body hit
 this._interactionEvents.createBoxHit(gfx, 'no-move', {
   width: element.width,
   height: element.height
 });
39968
 // add outline hit
 this._interactionEvents.createBoxHit(gfx, 'click-stroke', {
   width: element.width,
   height: element.height
 });
39974
 // add label hit
 this._interactionEvents.createBoxHit(gfx, 'all', {
   width: LABEL_WIDTH,
   height: element.height
 });
39980
 // indicate that we created a hit
 return true;
};
39984
BpmnInteractionEvents.prototype.createSubProcessHit = function(element, gfx) {
39986
 // remove existing hits
 this._interactionEvents.removeHits(gfx);
39989
 // add body hit
 this._interactionEvents.createBoxHit(gfx, 'no-move', {
   width: element.width,
   height: element.height
 });
39995
 // add outline hit
 this._interactionEvents.createBoxHit(gfx, 'click-stroke', {
   width: element.width,
   height: element.height
 });
40001
 // add label hit
 this._interactionEvents.createBoxHit(gfx, 'all', {
   width: element.width,
   height: LABEL_HEIGHT
 });
40007
 // indicate that we created a hit
 return true;
};
40011
var InteractionEventsModule = {
 __init__: [ 'bpmnInteractionEvents' ],
 bpmnInteractionEvents: [ 'type', BpmnInteractionEvents ]
};
40016
/**
* BPMN 2.0 specific keyboard bindings.
*
* @param {Injector} injector
*/
function BpmnKeyboardBindings(injector) {
 injector.invoke(KeyboardBindings, this);
}
40025
inherits$1(BpmnKeyboardBindings, KeyboardBindings);
40027
BpmnKeyboardBindings.$inject = [
 'injector'
];
40031
40032
/**
* Register available keyboard bindings.
*
* @param {Keyboard} keyboard
* @param {EditorActions} editorActions
*/
BpmnKeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {
40040
 // inherit default bindings
 KeyboardBindings.prototype.registerBindings.call(this, keyboard, editorActions);
40043
 /**
  * Add keyboard binding if respective editor action
  * is registered.
  *
  * @param {string} action name
  * @param {Function} fn that implements the key binding
  */
 function addListener(action, fn) {
40052
   if (editorActions.isRegistered(action)) {
     keyboard.addListener(fn);
   }
 }
40057
 // select all elements
 // CTRL + A
 addListener('selectElements', function(context) {
40061
   var event = context.keyEvent;
40063
   if (keyboard.isKey(['a', 'A'], event) && keyboard.isCmd(event)) {
     editorActions.trigger('selectElements');
40066
     return true;
   }
 });
40070
 // search labels
 // CTRL + F
 addListener('find', function(context) {
40074
   var event = context.keyEvent;
40076
   if (keyboard.isKey(['f', 'F'], event) && keyboard.isCmd(event)) {
     editorActions.trigger('find');
40079
     return true;
   }
 });
40083
 // activate space tool
 // S
 addListener('spaceTool', function(context) {
40087
   var event = context.keyEvent;
40089
   if (keyboard.hasModifier(event)) {
     return;
   }
40093
   if (keyboard.isKey(['s', 'S'], event)) {
     editorActions.trigger('spaceTool');
40096
     return true;
   }
 });
40100
 // activate lasso tool
 // L
 addListener('lassoTool', function(context) {
40104
   var event = context.keyEvent;
40106
   if (keyboard.hasModifier(event)) {
     return;
   }
40110
   if (keyboard.isKey(['l', 'L'], event)) {
     editorActions.trigger('lassoTool');
40113
     return true;
   }
 });
40117
 // activate hand tool
 // H
 addListener('handTool', function(context) {
40121
   var event = context.keyEvent;
40123
   if (keyboard.hasModifier(event)) {
     return;
   }
40127
   if (keyboard.isKey(['h', 'H'], event)) {
     editorActions.trigger('handTool');
40130
     return true;
   }
 });
40134
 // activate global connect tool
 // C
 addListener('globalConnectTool', function(context) {
40138
   var event = context.keyEvent;
40140
   if (keyboard.hasModifier(event)) {
     return;
   }
40144
   if (keyboard.isKey(['c', 'C'], event)) {
     editorActions.trigger('globalConnectTool');
40147
     return true;
   }
 });
40151
 // activate direct editing
 // E
 addListener('directEditing', function(context) {
40155
   var event = context.keyEvent;
40157
   if (keyboard.hasModifier(event)) {
     return;
   }
40161
   if (keyboard.isKey(['e', 'E'], event)) {
     editorActions.trigger('directEditing');
40164
     return true;
   }
 });
40168
};
40170
var KeyboardModule = {
 __depends__: [
   KeyboardModule$1
 ],
 __init__: [ 'keyboardBindings' ],
 keyboardBindings: [ 'type', BpmnKeyboardBindings ]
};
40178
var DEFAULT_CONFIG = {
 moveSpeed: 1,
 moveSpeedAccelerated: 10
};
40183
var HIGHER_PRIORITY$3 = 1500;
40185
var LEFT = 'left';
var UP = 'up';
var RIGHT = 'right';
var DOWN = 'down';
40190
var KEY_TO_DIRECTION = {
 ArrowLeft: LEFT,
 Left: LEFT,
 ArrowUp: UP,
 Up: UP,
 ArrowRight: RIGHT,
 Right: RIGHT,
 ArrowDown: DOWN,
 Down: DOWN
};
40201
var DIRECTIONS_DELTA = {
 left: function(speed) {
   return {
     x: -speed,
     y: 0
   };
 },
 up: function(speed) {
   return {
     x: 0,
     y: -speed
   };
 },
 right: function(speed) {
   return {
     x: speed,
     y: 0
   };
 },
 down: function(speed) {
   return {
     x: 0,
     y: speed
   };
 }
};
40228
40229
/**
* Enables to move selection with keyboard arrows.
* Use with Shift for modified speed (default=1, with Shift=10).
* Pressed Cmd/Ctrl turns the feature off.
*
* @param {Object} config
* @param {number} [config.moveSpeed=1]
* @param {number} [config.moveSpeedAccelerated=10]
* @param {Keyboard} keyboard
* @param {Modeling} modeling
* @param {Selection} selection
*/
function KeyboardMoveSelection(
   config,
   keyboard,
   modeling,
   rules,
   selection
) {
40249
 var self = this;
40251
 this._config = assign({}, DEFAULT_CONFIG, config || {});
40253
 keyboard.addListener(HIGHER_PRIORITY$3, function(event) {
40255
   var keyEvent = event.keyEvent;
40257
   var direction = KEY_TO_DIRECTION[keyEvent.key];
40259
   if (!direction) {
     return;
   }
40263
   if (keyboard.isCmd(keyEvent)) {
     return;
   }
40267
   var accelerated = keyboard.isShift(keyEvent);
40269
   self.moveSelection(direction, accelerated);
40271
   return true;
 });
40274
40275
 /**
  * Move selected elements in the given direction,
  * optionally specifying accelerated movement.
  *
  * @param {string} direction
  * @param {boolean} [accelerated=false]
  */
 this.moveSelection = function(direction, accelerated) {
40284
   var selectedElements = selection.get();
40286
   if (!selectedElements.length) {
     return;
   }
40290
   var speed = this._config[
     accelerated ?
       'moveSpeedAccelerated' :
       'moveSpeed'
   ];
40296
   var delta = DIRECTIONS_DELTA[direction](speed);
40298
   var canMove = rules.allowed('elements.move', {
     shapes: selectedElements
   });
40302
   if (canMove) {
     modeling.moveElements(selectedElements, delta);
   }
 };
40307
}
40309
KeyboardMoveSelection.$inject = [
 'config.keyboardMoveSelection',
 'keyboard',
 'modeling',
 'rules',
 'selection'
];
40317
var KeyboardMoveSelectionModule = {
 __depends__: [
   KeyboardModule$1,
   SelectionModule
 ],
 __init__: [
   'keyboardMoveSelection'
 ],
 keyboardMoveSelection: [ 'type', KeyboardMoveSelection ]
};
40328
var DEFAULT_MIN_WIDTH = 10;
40330
40331
/**
* A component that provides resizing of shapes on the canvas.
*
* The following components are part of shape resize:
*
*  * adding resize handles,
*  * creating a visual during resize
*  * checking resize rules
*  * committing a change once finished
*
*
* ## Customizing
*
* It's possible to customize the resizing behaviour by intercepting 'resize.start'
* and providing the following parameters through the 'context':
*
*   * minDimensions ({ width, height }): minimum shape dimensions
*
*   * childrenBoxPadding ({ left, top, bottom, right } || number):
*     gap between the minimum bounding box and the container
*
* f.ex:
*
* ```javascript
* eventBus.on('resize.start', 1500, function(event) {
*   var context = event.context,
*
*  context.minDimensions = { width: 140, height: 120 };
*
*  // Passing general padding
*  context.childrenBoxPadding = 30;
*
*  // Passing padding to a specific side
*  context.childrenBoxPadding.left = 20;
* });
* ```
*/
function Resize(eventBus, rules, modeling, dragging) {
40370
 this._dragging = dragging;
 this._rules = rules;
40373
 var self = this;
40375
40376
 /**
  * Handle resize move by specified delta.
  *
  * @param {Object} context
  * @param {Point} delta
  */
 function handleMove(context, delta) {
40384
   var shape = context.shape,
       direction = context.direction,
       resizeConstraints = context.resizeConstraints,
       newBounds;
40389
   context.delta = delta;
40391
   newBounds = resizeBounds$1(shape, direction, delta);
40393
   // ensure constraints during resize
   context.newBounds = ensureConstraints$1(newBounds, resizeConstraints);
40396
   // update + cache executable state
   context.canExecute = self.canResize(context);
 }
40400
 /**
  * Handle resize start.
  *
  * @param  {Object} context
  */
 function handleStart(context) {
40407
   var resizeConstraints = context.resizeConstraints,
40409
       // evaluate minBounds for backwards compatibility
       minBounds = context.minBounds;
40412
   if (resizeConstraints !== undefined) {
     return;
   }
40416
   if (minBounds === undefined) {
     minBounds = self.computeMinResizeBox(context);
   }
40420
   context.resizeConstraints = {
     min: asTRBL(minBounds)
   };
 }
40425
 /**
  * Handle resize end.
  *
  * @param  {Object} context
  */
 function handleEnd(context) {
   var shape = context.shape,
       canExecute = context.canExecute,
       newBounds = context.newBounds;
40435
   if (canExecute) {
40437
     // ensure we have actual pixel values for new bounds
     // (important when zoom level was > 1 during move)
     newBounds = roundBounds(newBounds);
40441
     if (!boundsChanged(shape, newBounds)) {
40443
       // no resize necessary
       return;
     }
40447
     // perform the actual resize
     modeling.resizeShape(shape, newBounds);
   }
 }
40452
40453
 eventBus.on('resize.start', function(event) {
   handleStart(event.context);
 });
40457
 eventBus.on('resize.move', function(event) {
   var delta = {
     x: event.dx,
     y: event.dy
   };
40463
   handleMove(event.context, delta);
 });
40466
 eventBus.on('resize.end', function(event) {
   handleEnd(event.context);
 });
40470
}
40472
40473
Resize.prototype.canResize = function(context) {
 var rules = this._rules;
40476
 var ctx = pick(context, [ 'newBounds', 'shape', 'delta', 'direction' ]);
40478
 return rules.allowed('shape.resize', ctx);
};
40481
/**
* Activate a resize operation.
*
* You may specify additional contextual information and must specify a
* resize direction during activation of the resize event.
*
* @param {MouseEvent} event
* @param {djs.model.Shape} shape
* @param {Object|string} contextOrDirection
*/
Resize.prototype.activate = function(event, shape, contextOrDirection) {
 var dragging = this._dragging,
     context,
     direction;
40496
 if (typeof contextOrDirection === 'string') {
   contextOrDirection = {
     direction: contextOrDirection
   };
 }
40502
 context = assign({ shape: shape }, contextOrDirection);
40504
 direction = context.direction;
40506
 if (!direction) {
   throw new Error('must provide a direction (n|w|s|e|nw|se|ne|sw)');
 }
40510
 dragging.init(event, getReferencePoint$1(shape, direction), 'resize', {
   autoActivate: true,
   cursor: getCursor(direction),
   data: {
     shape: shape,
     context: context
   }
 });
};
40520
Resize.prototype.computeMinResizeBox = function(context) {
 var shape = context.shape,
     direction = context.direction,
     minDimensions,
     childrenBounds;
40526
 minDimensions = context.minDimensions || {
   width: DEFAULT_MIN_WIDTH,
   height: DEFAULT_MIN_WIDTH
 };
40531
 // get children bounds
 childrenBounds = computeChildrenBBox(shape, context.childrenBoxPadding);
40534
 // get correct minimum bounds from given resize direction
 // basically ensures that the minBounds is max(childrenBounds, minDimensions)
 return getMinResizeBounds(direction, shape, minDimensions, childrenBounds);
};
40539
40540
Resize.$inject = [
 'eventBus',
 'rules',
 'modeling',
 'dragging'
];
40547
// helpers //////////
40549
function boundsChanged(shape, newBounds) {
 return shape.x !== newBounds.x ||
   shape.y !== newBounds.y ||
   shape.width !== newBounds.width ||
   shape.height !== newBounds.height;
}
40556
function getReferencePoint$1(shape, direction) {
 var mid = getMid(shape),
     trbl = asTRBL(shape);
40560
 var referencePoint = {
   x: mid.x,
   y: mid.y
 };
40565
 if (direction.indexOf('n') !== -1) {
   referencePoint.y = trbl.top;
 } else if (direction.indexOf('s') !== -1) {
   referencePoint.y = trbl.bottom;
 }
40571
 if (direction.indexOf('e') !== -1) {
   referencePoint.x = trbl.right;
 } else if (direction.indexOf('w') !== -1) {
   referencePoint.x = trbl.left;
 }
40577
 return referencePoint;
}
40580
function getCursor(direction) {
 var prefix = 'resize-';
40583
 if (direction === 'n' || direction === 's') {
   return prefix + 'ns';
 } else if (direction === 'e' || direction === 'w') {
   return prefix + 'ew';
 } else if (direction === 'nw' || direction === 'se') {
   return prefix + 'nwse';
 } else {
   return prefix + 'nesw';
 }
}
40594
var MARKER_RESIZING$1 = 'djs-resizing',
   MARKER_RESIZE_NOT_OK = 'resize-not-ok';
40597
var LOW_PRIORITY$e = 500;
40599
40600
/**
* Provides previews for resizing shapes when resizing.
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {PreviewSupport} previewSupport
*/
function ResizePreview(eventBus, canvas, previewSupport) {
40609
 /**
  * Update resizer frame.
  *
  * @param {Object} context
  */
 function updateFrame(context) {
40616
   var shape = context.shape,
       bounds = context.newBounds,
       frame = context.frame;
40620
   if (!frame) {
     frame = context.frame = previewSupport.addFrame(shape, canvas.getActiveLayer());
40623
     canvas.addMarker(shape, MARKER_RESIZING$1);
   }
40626
   if (bounds.width > 5) {
     attr$1(frame, { x: bounds.x, width: bounds.width });
   }
40630
   if (bounds.height > 5) {
     attr$1(frame, { y: bounds.y, height: bounds.height });
   }
40634
   if (context.canExecute) {
     classes$1(frame).remove(MARKER_RESIZE_NOT_OK);
   } else {
     classes$1(frame).add(MARKER_RESIZE_NOT_OK);
   }
 }
40641
 /**
  * Remove resizer frame.
  *
  * @param {Object} context
  */
 function removeFrame(context) {
   var shape = context.shape,
       frame = context.frame;
40650
   if (frame) {
     remove$2(context.frame);
   }
40654
   canvas.removeMarker(shape, MARKER_RESIZING$1);
 }
40657
 // add and update previews
 eventBus.on('resize.move', LOW_PRIORITY$e, function(event) {
   updateFrame(event.context);
 });
40662
 // remove previews
 eventBus.on('resize.cleanup', function(event) {
   removeFrame(event.context);
 });
40667
}
40669
ResizePreview.$inject = [
 'eventBus',
 'canvas',
 'previewSupport'
];
40675
var HANDLE_OFFSET = -6,
   HANDLE_SIZE = 4,
   HANDLE_HIT_SIZE = 20;
40679
var CLS_RESIZER = 'djs-resizer';
40681
var directions = [ 'n', 'w', 's', 'e', 'nw', 'ne', 'se', 'sw' ];
40683
40684
/**
* This component is responsible for adding resize handles.
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {Selection} selection
* @param {Resize} resize
*/
function ResizeHandles(eventBus, canvas, selection, resize) {
40694
 this._resize = resize;
 this._canvas = canvas;
40697
 var self = this;
40699
 eventBus.on('selection.changed', function(e) {
   var newSelection = e.newSelection;
40702
   // remove old selection markers
   self.removeResizers();
40705
   // add new selection markers ONLY if single selection
   if (newSelection.length === 1) {
     forEach$2(newSelection, bind(self.addResizer, self));
   }
 });
40711
 eventBus.on('shape.changed', function(e) {
   var shape = e.element;
40714
   if (selection.isSelected(shape)) {
     self.removeResizers();
40717
     self.addResizer(shape);
   }
 });
}
40722
40723
ResizeHandles.prototype.makeDraggable = function(element, gfx, direction) {
 var resize = this._resize;
40726
 function startResize(event) {
40728
   // only trigger on left mouse button
   if (isPrimaryButton(event)) {
     resize.activate(event, element, direction);
   }
 }
40734
 componentEvent.bind(gfx, 'mousedown', startResize);
 componentEvent.bind(gfx, 'touchstart', startResize);
};
40738
40739
ResizeHandles.prototype._createResizer = function(element, x, y, direction) {
 var resizersParent = this._getResizersParent();
40742
 var offset = getHandleOffset(direction);
40744
 var group = create$1('g');
40746
 classes$1(group).add(CLS_RESIZER);
 classes$1(group).add(CLS_RESIZER + '-' + element.id);
 classes$1(group).add(CLS_RESIZER + '-' + direction);
40750
 append(resizersParent, group);
40752
 var visual = create$1('rect');
40754
 attr$1(visual, {
   x: -HANDLE_SIZE / 2 + offset.x,
   y: -HANDLE_SIZE / 2 + offset.y,
   width: HANDLE_SIZE,
   height: HANDLE_SIZE
 });
40761
 classes$1(visual).add(CLS_RESIZER + '-visual');
40763
 append(group, visual);
40765
 var hit = create$1('rect');
40767
 attr$1(hit, {
   x: -HANDLE_HIT_SIZE / 2 + offset.x,
   y: -HANDLE_HIT_SIZE / 2 + offset.y,
   width: HANDLE_HIT_SIZE,
   height: HANDLE_HIT_SIZE
 });
40774
 classes$1(hit).add(CLS_RESIZER + '-hit');
40776
 append(group, hit);
40778
 transform(group, x, y);
40780
 return group;
};
40783
ResizeHandles.prototype.createResizer = function(element, direction) {
 var point = getReferencePoint$1(element, direction);
40786
 var resizer = this._createResizer(element, point.x, point.y, direction);
40788
 this.makeDraggable(element, resizer, direction);
};
40791
// resize handles implementation ///////////////////////////////
40793
/**
* Add resizers for a given element.
*
* @param {djs.model.Shape} shape
*/
ResizeHandles.prototype.addResizer = function(shape) {
 var self = this;
40801
 var resize = this._resize;
40803
 if (!resize.canResize({ shape: shape })) {
   return;
 }
40807
 forEach$2(directions, function(direction) {
   self.createResizer(shape, direction);
 });
};
40812
/**
* Remove all resizers
*/
ResizeHandles.prototype.removeResizers = function() {
 var resizersParent = this._getResizersParent();
40818
 clear$1(resizersParent);
};
40821
ResizeHandles.prototype._getResizersParent = function() {
 return this._canvas.getLayer('resizers');
};
40825
ResizeHandles.$inject = [
 'eventBus',
 'canvas',
 'selection',
 'resize'
];
40832
// helpers //////////
40834
function getHandleOffset(direction) {
 var offset = {
   x: 0,
   y: 0
 };
40840
 if (direction.indexOf('e') !== -1) {
   offset.x = -HANDLE_OFFSET;
 } else if (direction.indexOf('w') !== -1) {
   offset.x = HANDLE_OFFSET;
 }
40846
 if (direction.indexOf('s') !== -1) {
   offset.y = -HANDLE_OFFSET;
 } else if (direction.indexOf('n') !== -1) {
   offset.y = HANDLE_OFFSET;
 }
40852
 return offset;
}
40855
var ResizeModule = {
 __depends__: [
   RulesModule$1,
   DraggingModule,
   PreviewSupportModule
 ],
 __init__: [
   'resize',
   'resizePreview',
   'resizeHandles'
 ],
 resize: [ 'type', Resize ],
 resizePreview: [ 'type', ResizePreview ],
 resizeHandles: [ 'type', ResizeHandles ]
};
40871
/**
* Creates a new bpmn:CategoryValue inside a new bpmn:Category
*
* @param {ModdleElement} definitions
* @param {BpmnFactory} bpmnFactory
*
* @return {ModdleElement} categoryValue.
*/
function createCategoryValue(definitions, bpmnFactory) {
 var categoryValue = bpmnFactory.create('bpmn:CategoryValue'),
     category = bpmnFactory.create('bpmn:Category', {
       categoryValue: [ categoryValue ]
     });
40885
 // add to correct place
 add(definitions.get('rootElements'), category);
 getBusinessObject(category).$parent = definitions;
 getBusinessObject(categoryValue).$parent = category;
40890
 return categoryValue;
40892
}
40894
function LabelEditingProvider(
   eventBus, bpmnFactory, canvas, directEditing,
   modeling, resizeHandles, textRenderer) {
40898
 this._bpmnFactory = bpmnFactory;
 this._canvas = canvas;
 this._modeling = modeling;
 this._textRenderer = textRenderer;
40903
 directEditing.registerProvider(this);
40905
 // listen to dblclick on non-root elements
 eventBus.on('element.dblclick', function(event) {
   activateDirectEdit(event.element, true);
 });
40910
 // complete on followup canvas operation
 eventBus.on([
   'autoPlace.start',
   'canvas.viewbox.changing',
   'drag.init',
   'element.mousedown',
   'popupMenu.open',
   'root.set',
   'selection.changed'
 ], function(event) {
40921
   if (directEditing.isActive()) {
     directEditing.complete();
   }
 });
40926
 // cancel on command stack changes
 eventBus.on([ 'commandStack.changed' ], function(e) {
   if (directEditing.isActive()) {
     directEditing.cancel();
   }
 });
40933
40934
 eventBus.on('directEditing.activate', function(event) {
   resizeHandles.removeResizers();
 });
40938
 eventBus.on('create.end', 500, function(event) {
40940
   var context = event.context,
       element = context.shape,
       canExecute = event.context.canExecute,
       isTouch = event.isTouch;
40945
   // TODO(nikku): we need to find a way to support the
   // direct editing on mobile devices; right now this will
   // break for desworkflowediting on mobile devices
   // as it breaks the user interaction workflow
40950
   // TODO(nre): we should temporarily focus the edited element
   // here and release the focused viewport after the direct edit
   // operation is finished
   if (isTouch) {
     return;
   }
40957
   if (!canExecute) {
     return;
   }
40961
   if (context.hints && context.hints.createElementsBehavior === false) {
     return;
   }
40965
   activateDirectEdit(element);
 });
40968
 eventBus.on('autoPlace.end', 500, function(event) {
   activateDirectEdit(event.shape);
 });
40972
40973
 function activateDirectEdit(element, force) {
   if (force ||
       isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation' ]) ||
       isCollapsedSubProcess(element)) {
40978
     directEditing.activate(element);
   }
 }
40982
}
40984
LabelEditingProvider.$inject = [
 'eventBus',
 'bpmnFactory',
 'canvas',
 'directEditing',
 'modeling',
 'resizeHandles',
 'textRenderer'
];
40994
40995
/**
* Activate direct editing for activities and text annotations.
*
* @param  {djs.model.Base} element
*
* @return {Object} an object with properties bounds (position and size), text and options
*/
LabelEditingProvider.prototype.activate = function(element) {
41004
 // text
 var text = getLabel(element);
41007
 if (text === undefined) {
   return;
 }
41011
 var context = {
   text: text
 };
41015
 // bounds
 var bounds = this.getEditingBBox(element);
41018
 assign(context, bounds);
41020
 var options = {};
41022
 // tasks
 if (
   isAny(element, [
     'bpmn:Task',
     'bpmn:Participant',
     'bpmn:Lane',
     'bpmn:CallActivity'
   ]) ||
   isCollapsedSubProcess(element)
 ) {
   assign(options, {
     centerVertically: true
   });
 }
41037
 // external labels
 if (isLabelExternal(element)) {
   assign(options, {
     autoResize: true
   });
 }
41044
 // text annotations
 if (is$1(element, 'bpmn:TextAnnotation')) {
   assign(options, {
     resizable: true,
     autoResize: true
   });
 }
41052
 assign(context, {
   options: options
 });
41056
 return context;
};
41059
41060
/**
* Get the editing bounding box based on the element's size and position
*
* @param  {djs.model.Base} element
*
* @return {Object} an object containing information about position
*                  and size (fixed or minimum and/or maximum)
*/
LabelEditingProvider.prototype.getEditingBBox = function(element) {
 var canvas = this._canvas;
41071
 var target = element.label || element;
41073
 var bbox = canvas.getAbsoluteBBox(target);
41075
 var mid = {
   x: bbox.x + bbox.width / 2,
   y: bbox.y + bbox.height / 2
 };
41080
 // default position
 var bounds = { x: bbox.x, y: bbox.y };
41083
 var zoom = canvas.zoom();
41085
 var defaultStyle = this._textRenderer.getDefaultStyle(),
     externalStyle = this._textRenderer.getExternalStyle();
41088
 // take zoom into account
 var externalFontSize = externalStyle.fontSize * zoom,
     externalLineHeight = externalStyle.lineHeight,
     defaultFontSize = defaultStyle.fontSize * zoom,
     defaultLineHeight = defaultStyle.lineHeight;
41094
 var style = {
   fontFamily: this._textRenderer.getDefaultStyle().fontFamily,
   fontWeight: this._textRenderer.getDefaultStyle().fontWeight
 };
41099
 // adjust for expanded pools AND lanes
 if (is$1(element, 'bpmn:Lane') || isExpandedPool(element)) {
41102
   assign(bounds, {
     width: bbox.height,
     height: 30 * zoom,
     x: bbox.x - bbox.height / 2 + (15 * zoom),
     y: mid.y - (30 * zoom) / 2
   });
41109
   assign(style, {
     fontSize: defaultFontSize + 'px',
     lineHeight: defaultLineHeight,
     paddingTop: (7 * zoom) + 'px',
     paddingBottom: (7 * zoom) + 'px',
     paddingLeft: (5 * zoom) + 'px',
     paddingRight: (5 * zoom) + 'px',
     transform: 'rotate(-90deg)'
   });
 }
41120
41121
 // internal labels for tasks and collapsed call activities,
 // sub processes and participants
 if (isAny(element, [ 'bpmn:Task', 'bpmn:CallActivity']) ||
     isCollapsedPool(element) ||
     isCollapsedSubProcess(element)) {
41127
   assign(bounds, {
     width: bbox.width,
     height: bbox.height
   });
41132
   assign(style, {
     fontSize: defaultFontSize + 'px',
     lineHeight: defaultLineHeight,
     paddingTop: (7 * zoom) + 'px',
     paddingBottom: (7 * zoom) + 'px',
     paddingLeft: (5 * zoom) + 'px',
     paddingRight: (5 * zoom) + 'px'
   });
 }
41142
41143
 // internal labels for expanded sub processes
 if (isExpandedSubProcess$1(element)) {
   assign(bounds, {
     width: bbox.width,
     x: bbox.x
   });
41150
   assign(style, {
     fontSize: defaultFontSize + 'px',
     lineHeight: defaultLineHeight,
     paddingTop: (7 * zoom) + 'px',
     paddingBottom: (7 * zoom) + 'px',
     paddingLeft: (5 * zoom) + 'px',
     paddingRight: (5 * zoom) + 'px'
   });
 }
41160
 var width = 90 * zoom,
     paddingTop = 7 * zoom,
     paddingBottom = 4 * zoom;
41164
 // external labels for events, data elements, gateways, groups and connections
 if (target.labelTarget) {
   assign(bounds, {
     width: width,
     height: bbox.height + paddingTop + paddingBottom,
     x: mid.x - width / 2,
     y: bbox.y - paddingTop
   });
41173
   assign(style, {
     fontSize: externalFontSize + 'px',
     lineHeight: externalLineHeight,
     paddingTop: paddingTop + 'px',
     paddingBottom: paddingBottom + 'px'
   });
 }
41181
 // external label not yet created
 if (isLabelExternal(target)
     && !hasExternalLabel(target)
     && !isLabel$6(target)) {
41186
   var externalLabelMid = getExternalLabelMid(element);
41188
   var absoluteBBox = canvas.getAbsoluteBBox({
     x: externalLabelMid.x,
     y: externalLabelMid.y,
     width: 0,
     height: 0
   });
41195
   var height = externalFontSize + paddingTop + paddingBottom;
41197
   assign(bounds, {
     width: width,
     height: height,
     x: absoluteBBox.x - width / 2,
     y: absoluteBBox.y - height / 2
   });
41204
   assign(style, {
     fontSize: externalFontSize + 'px',
     lineHeight: externalLineHeight,
     paddingTop: paddingTop + 'px',
     paddingBottom: paddingBottom + 'px'
   });
 }
41212
 // text annotations
 if (is$1(element, 'bpmn:TextAnnotation')) {
   assign(bounds, {
     width: bbox.width,
     height: bbox.height,
     minWidth: 30 * zoom,
     minHeight: 10 * zoom
   });
41221
   assign(style, {
     textAlign: 'left',
     paddingTop: (5 * zoom) + 'px',
     paddingBottom: (7 * zoom) + 'px',
     paddingLeft: (7 * zoom) + 'px',
     paddingRight: (5 * zoom) + 'px',
     fontSize: defaultFontSize + 'px',
     lineHeight: defaultLineHeight
   });
 }
41232
 return { bounds: bounds, style: style };
};
41235
41236
LabelEditingProvider.prototype.update = function(
   element, newLabel,
   activeContextText, bounds) {
41240
 var newBounds,
     bbox;
41243
 if (is$1(element, 'bpmn:TextAnnotation')) {
41245
   bbox = this._canvas.getAbsoluteBBox(element);
41247
   newBounds = {
     x: element.x,
     y: element.y,
     width: element.width / bbox.width * bounds.width,
     height: element.height / bbox.height * bounds.height
   };
 }
41255
 if (is$1(element, 'bpmn:Group')) {
41257
   var businessObject = getBusinessObject(element);
41259
   // initialize categoryValue if not existing
   if (!businessObject.categoryValueRef) {
41262
     var rootElement = this._canvas.getRootElement(),
         definitions = getBusinessObject(rootElement).$parent;
41265
     var categoryValue = createCategoryValue(definitions, this._bpmnFactory);
41267
     getBusinessObject(element).categoryValueRef = categoryValue;
   }
41270
 }
41272
 if (isEmptyText$1(newLabel)) {
   newLabel = null;
 }
41276
 this._modeling.updateLabel(element, newLabel, newBounds);
};
41279
41280
41281
// helpers //////////////////////
41283
function isCollapsedSubProcess(element) {
 return is$1(element, 'bpmn:SubProcess') && !isExpanded(element);
}
41287
function isExpandedSubProcess$1(element) {
 return is$1(element, 'bpmn:SubProcess') && isExpanded(element);
}
41291
function isCollapsedPool(element) {
 return is$1(element, 'bpmn:Participant') && !isExpanded(element);
}
41295
function isExpandedPool(element) {
 return is$1(element, 'bpmn:Participant') && isExpanded(element);
}
41299
function isEmptyText$1(label) {
 return !label || !label.trim();
}
41303
var MARKER_HIDDEN = 'djs-element-hidden',
   MARKER_LABEL_HIDDEN = 'djs-label-hidden';
41306
41307
function LabelEditingPreview(
   eventBus, canvas, elementRegistry,
   pathMap) {
41311
 var self = this;
41313
 var defaultLayer = canvas.getDefaultLayer();
41315
 var element, absoluteElementBBox, gfx;
41317
 eventBus.on('directEditing.activate', function(context) {
   var activeProvider = context.active;
41320
   element = activeProvider.element.label || activeProvider.element;
41322
   // text annotation
   if (is$1(element, 'bpmn:TextAnnotation')) {
     absoluteElementBBox = canvas.getAbsoluteBBox(element);
41326
     gfx = create$1('g');
41328
     var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: element.height,
       position: {
         mx: 0.0,
         my: 0.0
       }
     });
41339
     var path = self.path = create$1('path');
41341
     attr$1(path, {
       d: textPathData,
       strokeWidth: 2,
       stroke: getStrokeColor(element)
     });
41347
     append(gfx, path);
41349
     append(defaultLayer, gfx);
41351
     translate$2(gfx, element.x, element.y);
   }
41354
   if (is$1(element, 'bpmn:TextAnnotation') ||
       element.labelTarget) {
     canvas.addMarker(element, MARKER_HIDDEN);
   } else if (is$1(element, 'bpmn:Task') ||
              is$1(element, 'bpmn:CallActivity') ||
              is$1(element, 'bpmn:SubProcess') ||
              is$1(element, 'bpmn:Participant')) {
     canvas.addMarker(element, MARKER_LABEL_HIDDEN);
   }
 });
41365
 eventBus.on('directEditing.resize', function(context) {
41367
   // text annotation
   if (is$1(element, 'bpmn:TextAnnotation')) {
     var height = context.height,
         dy = context.dy;
41372
     var newElementHeight = Math.max(element.height / absoluteElementBBox.height * (height + dy), 0);
41374
     var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {
       xScaleFactor: 1,
       yScaleFactor: 1,
       containerWidth: element.width,
       containerHeight: newElementHeight,
       position: {
         mx: 0.0,
         my: 0.0
       }
     });
41385
     attr$1(self.path, {
       d: textPathData
     });
   }
 });
41391
 eventBus.on([ 'directEditing.complete', 'directEditing.cancel' ], function(context) {
   var activeProvider = context.active;
41394
   if (activeProvider) {
     canvas.removeMarker(activeProvider.element.label || activeProvider.element, MARKER_HIDDEN);
     canvas.removeMarker(element, MARKER_LABEL_HIDDEN);
   }
41399
   element = undefined;
   absoluteElementBBox = undefined;
41402
   if (gfx) {
     remove$2(gfx);
41405
     gfx = undefined;
   }
 });
}
41410
LabelEditingPreview.$inject = [
 'eventBus',
 'canvas',
 'elementRegistry',
 'pathMap'
];
41417
41418
// helpers ///////////////////
41420
function getStrokeColor(element, defaultColor) {
 var di = getDi(element);
41423
 return di.get('stroke') || defaultColor || 'black';
}
41426
var LabelEditingModule = {
 __depends__: [
   ChangeSupportModule,
   ResizeModule,
   DirectEditingModule
 ],
 __init__: [
   'labelEditingProvider',
   'labelEditingPreview'
 ],
 labelEditingProvider: [ 'type', LabelEditingProvider ],
 labelEditingPreview: [ 'type', LabelEditingPreview ]
};
41440
var ALIGNMENTS = [
 'top',
 'bottom',
 'left',
 'right'
];
41447
var ELEMENT_LABEL_DISTANCE = 10;
41449
/**
* A component that makes sure that external labels are added
* together with respective elements and properly updated (DI wise)
* during move.
*
* @param {EventBus} eventBus
* @param {Modeling} modeling
*/
function AdaptiveLabelPositioningBehavior(eventBus, modeling) {
41459
 CommandInterceptor.call(this, eventBus);
41461
 this.postExecuted([
   'connection.create',
   'connection.layout',
   'connection.updateWaypoints'
 ], function(event) {
   var context = event.context,
       connection = context.connection,
       source = connection.source,
       target = connection.target,
       hints = context.hints || {};
41472
   if (hints.createElementsBehavior !== false) {
     checkLabelAdjustment(source);
     checkLabelAdjustment(target);
   }
 });
41478
41479
 this.postExecuted([
   'label.create'
 ], function(event) {
   var context = event.context,
       shape = context.shape,
       hints = context.hints || {};
41486
   if (hints.createElementsBehavior !== false) {
     checkLabelAdjustment(shape.labelTarget);
   }
 });
41491
41492
 this.postExecuted([
   'elements.create'
 ], function(event) {
   var context = event.context,
       elements = context.elements,
       hints = context.hints || {};
41499
   if (hints.createElementsBehavior !== false) {
     elements.forEach(function(element) {
       checkLabelAdjustment(element);
     });
   }
 });
41506
 function checkLabelAdjustment(element) {
41508
   // skip non-existing labels
   if (!hasExternalLabel(element)) {
     return;
   }
41513
   var optimalPosition = getOptimalPosition(element);
41515
   // no optimal position found
   if (!optimalPosition) {
     return;
   }
41520
   adjustLabelPosition(element, optimalPosition);
 }
41523
 function adjustLabelPosition(element, orientation) {
41525
   var elementMid = getMid(element),
       label = element.label,
       labelMid = getMid(label);
41529
   // ignore labels that are being created
   if (!label.parent) {
     return;
   }
41534
   var elementTrbl = asTRBL(element);
41536
   var newLabelMid;
41538
   switch (orientation) {
   case 'top':
     newLabelMid = {
       x: elementMid.x,
       y: elementTrbl.top - ELEMENT_LABEL_DISTANCE - label.height / 2
     };
41545
     break;
41547
   case 'left':
41549
     newLabelMid = {
       x: elementTrbl.left - ELEMENT_LABEL_DISTANCE - label.width / 2,
       y: elementMid.y
     };
41554
     break;
41556
   case 'bottom':
41558
     newLabelMid = {
       x: elementMid.x,
       y: elementTrbl.bottom + ELEMENT_LABEL_DISTANCE + label.height / 2
     };
41563
     break;
41565
   case 'right':
41567
     newLabelMid = {
       x: elementTrbl.right + ELEMENT_LABEL_DISTANCE + label.width / 2,
       y: elementMid.y
     };
41572
     break;
   }
41575
   var delta$1 = delta(newLabelMid, labelMid);
41577
   modeling.moveShape(label, delta$1);
 }
41580
}
41582
inherits$1(AdaptiveLabelPositioningBehavior, CommandInterceptor);
41584
AdaptiveLabelPositioningBehavior.$inject = [
 'eventBus',
 'modeling'
];
41589
41590
// helpers //////////////////////
41592
/**
* Return alignments which are taken by a boundary's host element
*
* @param {Shape} element
*
* @return {Array<string>}
*/
function getTakenHostAlignments(element) {
41601
 var hostElement = element.host,
     elementMid = getMid(element),
     hostOrientation = getOrientation(elementMid, hostElement);
41605
 var freeAlignments;
41607
 // check whether there is a multi-orientation, e.g. 'top-left'
 if (hostOrientation.indexOf('-') >= 0) {
   freeAlignments = hostOrientation.split('-');
 } else {
   freeAlignments = [ hostOrientation ];
 }
41614
 var takenAlignments = ALIGNMENTS.filter(function(alignment) {
41616
   return freeAlignments.indexOf(alignment) === -1;
 });
41619
 return takenAlignments;
41621
}
41623
/**
* Return alignments which are taken by related connections
*
* @param {Shape} element
*
* @return {Array<string>}
*/
function getTakenConnectionAlignments(element) {
41632
 var elementMid = getMid(element);
41634
 var takenAlignments = [].concat(
   element.incoming.map(function(c) {
     return c.waypoints[c.waypoints.length - 2 ];
   }),
   element.outgoing.map(function(c) {
     return c.waypoints[1];
   })
 ).map(function(point) {
   return getApproximateOrientation(elementMid, point);
 });
41645
 return takenAlignments;
}
41648
/**
* Return the optimal label position around an element
* or _undefined_, if none was found.
*
* @param  {Shape} element
*
* @return {string} positioning identifier
*/
function getOptimalPosition(element) {
41658
 var labelMid = getMid(element.label);
41660
 var elementMid = getMid(element);
41662
 var labelOrientation = getApproximateOrientation(elementMid, labelMid);
41664
 if (!isAligned(labelOrientation)) {
   return;
 }
41668
 var takenAlignments = getTakenConnectionAlignments(element);
41670
 if (element.host) {
   var takenHostAlignments = getTakenHostAlignments(element);
41673
   takenAlignments = takenAlignments.concat(takenHostAlignments);
 }
41676
 var freeAlignments = ALIGNMENTS.filter(function(alignment) {
41678
   return takenAlignments.indexOf(alignment) === -1;
 });
41681
 // NOTHING TO DO; label already aligned a.O.K.
 if (freeAlignments.indexOf(labelOrientation) !== -1) {
   return;
 }
41686
 return freeAlignments[0];
}
41689
function getApproximateOrientation(p0, p1) {
 return getOrientation(p1, p0, 5);
}
41693
function isAligned(orientation) {
 return ALIGNMENTS.indexOf(orientation) !== -1;
}
41697
function AppendBehavior(eventBus, elementFactory, bpmnRules) {
41699
 CommandInterceptor.call(this, eventBus);
41701
 // assign correct shape position unless already set
41703
 this.preExecute('shape.append', function(context) {
41705
   var source = context.source,
       shape = context.shape;
41708
   if (!context.position) {
41710
     if (is$1(shape, 'bpmn:TextAnnotation')) {
       context.position = {
         x: source.x + source.width / 2 + 75,
         y: source.y - (50) - shape.height / 2
       };
     } else {
       context.position = {
         x: source.x + source.width + 80 + shape.width / 2,
         y: source.y + source.height / 2
       };
     }
   }
 }, true);
}
41725
inherits$1(AppendBehavior, CommandInterceptor);
41727
AppendBehavior.$inject = [
 'eventBus',
 'elementFactory',
 'bpmnRules'
];
41733
function AssociationBehavior(injector, modeling) {
 injector.invoke(CommandInterceptor, this);
41736
 this.postExecute('shape.move', function(context) {
   var newParent = context.newParent,
       shape = context.shape;
41740
   var associations = filter(shape.incoming.concat(shape.outgoing), function(connection) {
     return is$1(connection, 'bpmn:Association');
   });
41744
   forEach$2(associations, function(association) {
     modeling.moveConnection(association, { x: 0, y: 0 }, newParent);
   });
 }, true);
}
41750
inherits$1(AssociationBehavior, CommandInterceptor);
41752
AssociationBehavior.$inject = [
 'injector',
 'modeling'
];
41757
var LOW_PRIORITY$d = 500;
41759
41760
/**
* Replace intermediate event with boundary event when creating or moving results in attached event.
*/
function AttachEventBehavior(bpmnReplace, injector) {
 injector.invoke(CommandInterceptor, this);
41766
 this._bpmnReplace = bpmnReplace;
41768
 var self = this;
41770
 this.postExecuted('elements.create', LOW_PRIORITY$d, function(context) {
   var elements = context.elements;
41773
   elements = elements.filter(function(shape) {
     var host = shape.host;
41776
     return shouldReplace$1(shape, host);
   });
41779
   if (elements.length !== 1) {
     return;
   }
41783
   elements.map(function(element) {
     return elements.indexOf(element);
   }).forEach(function(index) {
     var host = elements[ index ];
41788
     context.elements[ index ] = self.replaceShape(elements[ index ], host);
   });
 }, true);
41792
41793
 this.preExecute('elements.move', LOW_PRIORITY$d, function(context) {
   var shapes = context.shapes,
       host = context.newHost;
41797
   if (shapes.length !== 1) {
     return;
   }
41801
   var shape = shapes[0];
41803
   if (shouldReplace$1(shape, host)) {
     context.shapes = [ self.replaceShape(shape, host) ];
   }
 }, true);
}
41809
AttachEventBehavior.$inject = [
 'bpmnReplace',
 'injector'
];
41814
inherits$1(AttachEventBehavior, CommandInterceptor);
41816
AttachEventBehavior.prototype.replaceShape = function(shape, host) {
 var eventDefinition = getEventDefinition$1(shape);
41819
 var boundaryEvent = {
   type: 'bpmn:BoundaryEvent',
   host: host
 };
41824
 if (eventDefinition) {
   boundaryEvent.eventDefinitionType = eventDefinition.$type;
 }
41828
 return this._bpmnReplace.replaceElement(shape, boundaryEvent, { layoutConnection: false });
};
41831
41832
// helpers //////////
41834
function getEventDefinition$1(element) {
 var businessObject = getBusinessObject(element),
     eventDefinitions = businessObject.eventDefinitions;
41838
 return eventDefinitions && eventDefinitions[0];
}
41841
function shouldReplace$1(shape, host) {
 return !isLabel$6(shape) &&
   isAny(shape, [ 'bpmn:IntermediateThrowEvent', 'bpmn:IntermediateCatchEvent' ]) && !!host;
}
41846
var HIGH_PRIORITY$d = 2000;
41848
41849
/**
* BPMN specific boundary event behavior
*/
function BoundaryEventBehavior(eventBus, moddle, modeling) {
41854
 CommandInterceptor.call(this, eventBus);
41856
 function getBoundaryEvents(element) {
   return filter(element.attachers, function(attacher) {
     return is$1(attacher, 'bpmn:BoundaryEvent');
   });
 }
41862
 // remove after connecting to event-based gateway
 this.postExecute('connection.create', function(event) {
   var source = event.context.source,
       target = event.context.target,
       boundaryEvents = getBoundaryEvents(target);
41868
   if (
     is$1(source, 'bpmn:EventBasedGateway') &&
     is$1(target, 'bpmn:ReceiveTask') &&
     boundaryEvents.length > 0
   ) {
     modeling.removeElements(boundaryEvents);
   }
41876
 });
41878
 // remove after replacing connected gateway with event-based gateway
 this.postExecute('connection.reconnect', function(event) {
   var oldSource = event.context.oldSource,
       newSource = event.context.newSource;
41883
   if (is$1(oldSource, 'bpmn:Gateway') &&
       is$1(newSource, 'bpmn:EventBasedGateway')) {
     forEach$2(newSource.outgoing, function(connection) {
       var target = connection.target,
           attachedboundaryEvents = getBoundaryEvents(target);
41889
       if (is$1(target, 'bpmn:ReceiveTask') &&
           attachedboundaryEvents.length > 0) {
         modeling.removeElements(attachedboundaryEvents);
       }
     });
   }
 });
41897
 // copy reference to root element on replace
 eventBus.on('moddleCopy.canCopyProperty', HIGH_PRIORITY$d, function(context) {
   var parent = context.parent,
       property = context.property,
       propertyName = context.propertyName;
41903
   var propertyDescriptor = moddle.getPropertyDescriptor(parent, propertyName);
41905
   if (propertyDescriptor && propertyDescriptor.isReference && is$1(property, 'bpmn:RootElement')) {
     parent.set(propertyName, property);
   }
 });
}
41911
BoundaryEventBehavior.$inject = [
 'eventBus',
 'moddle',
 'modeling'
];
41917
inherits$1(BoundaryEventBehavior, CommandInterceptor);
41919
function CreateBehavior(injector) {
 injector.invoke(CommandInterceptor, this);
41922
 this.preExecute('shape.create', 1500, function(event) {
   var context = event.context,
       parent = context.parent,
       shape = context.shape;
41927
   if (is$1(parent, 'bpmn:Lane') && !is$1(shape, 'bpmn:Lane')) {
     context.parent = getParent(parent, 'bpmn:Participant');
   }
 });
41932
}
41934
41935
CreateBehavior.$inject = [ 'injector' ];
41937
inherits$1(CreateBehavior, CommandInterceptor);
41939
/**
* BPMN specific create data object behavior
*/
function CreateDataObjectBehavior(eventBus, bpmnFactory, moddle) {
41944
 CommandInterceptor.call(this, eventBus);
41946
 this.preExecute('shape.create', function(event) {
41948
   var context = event.context,
       shape = context.shape;
41951
   if (is$1(shape, 'bpmn:DataObjectReference') && shape.type !== 'label') {
41953
     // create a DataObject every time a DataObjectReference is created
     var dataObject = bpmnFactory.create('bpmn:DataObject');
41956
     // set the reference to the DataObject
     shape.businessObject.dataObjectRef = dataObject;
   }
 });
41961
}
41963
CreateDataObjectBehavior.$inject = [
 'eventBus',
 'bpmnFactory',
 'moddle'
];
41969
inherits$1(CreateDataObjectBehavior, CommandInterceptor);
41971
var HORIZONTAL_PARTICIPANT_PADDING = 20,
   VERTICAL_PARTICIPANT_PADDING = 20;
41974
var PARTICIPANT_BORDER_WIDTH = 30;
41976
var HIGH_PRIORITY$c = 2000;
41978
41979
/**
* BPMN-specific behavior for creating participants.
*/
function CreateParticipantBehavior(canvas, eventBus, modeling) {
 CommandInterceptor.call(this, eventBus);
41985
 // fit participant
 eventBus.on([
   'create.start',
   'shape.move.start'
 ], HIGH_PRIORITY$c, function(event) {
   var context = event.context,
       shape = context.shape,
       rootElement = canvas.getRootElement();
41994
   if (!is$1(shape, 'bpmn:Participant') ||
     !is$1(rootElement, 'bpmn:Process') ||
     !rootElement.children.length) {
     return;
   }
42000
   // ignore connections, groups and labels
   var children = rootElement.children.filter(function(element) {
     return !is$1(element, 'bpmn:Group') &&
       !isLabel$6(element) &&
       !isConnection$9(element);
   });
42007
   // ensure for available children to calculate bounds
   if (!children.length) {
     return;
   }
42012
   var childrenBBox = getBBox(children);
42014
   var participantBounds = getParticipantBounds(shape, childrenBBox);
42016
   // assign width and height
   assign(shape, participantBounds);
42019
   // assign create constraints
   context.createConstraints = getParticipantCreateConstraints(shape, childrenBBox);
 });
42023
 // force hovering process when creating first participant
 eventBus.on('create.start', HIGH_PRIORITY$c, function(event) {
   var context = event.context,
       shape = context.shape,
       rootElement = canvas.getRootElement(),
       rootElementGfx = canvas.getGraphics(rootElement);
42030
   function ensureHoveringProcess(event) {
     event.element = rootElement;
     event.gfx = rootElementGfx;
   }
42035
   if (is$1(shape, 'bpmn:Participant') && is$1(rootElement, 'bpmn:Process')) {
     eventBus.on('element.hover', HIGH_PRIORITY$c, ensureHoveringProcess);
42038
     eventBus.once('create.cleanup', function() {
       eventBus.off('element.hover', ensureHoveringProcess);
     });
   }
 });
42044
 // turn process into collaboration when creating first participant
 function getOrCreateCollaboration() {
   var rootElement = canvas.getRootElement();
42048
   if (is$1(rootElement, 'bpmn:Collaboration')) {
     return rootElement;
   }
42052
   return modeling.makeCollaboration();
 }
42055
 // when creating mutliple elements through `elements.create` parent must be set to collaboration
 // and passed to `shape.create` as hint
 this.preExecute('elements.create', HIGH_PRIORITY$c, function(context) {
   var elements = context.elements,
       parent = context.parent,
       participant = findParticipant(elements),
       hints;
42063
   if (participant && is$1(parent, 'bpmn:Process')) {
     context.parent = getOrCreateCollaboration();
42066
     hints = context.hints = context.hints || {};
42068
     hints.participant = participant;
     hints.process = parent;
     hints.processRef = getBusinessObject(participant).get('processRef');
   }
 }, true);
42074
 // when creating single shape through `shape.create` parent must be set to collaboration
 // unless it was already set through `elements.create`
 this.preExecute('shape.create', function(context) {
   var parent = context.parent,
       shape = context.shape;
42080
   if (is$1(shape, 'bpmn:Participant') && is$1(parent, 'bpmn:Process')) {
     context.parent = getOrCreateCollaboration();
42083
     context.process = parent;
     context.processRef = getBusinessObject(shape).get('processRef');
   }
 }, true);
42088
 // #execute necessary because #preExecute not called on CommandStack#redo
 this.execute('shape.create', function(context) {
   var hints = context.hints || {},
       process = context.process || hints.process,
       shape = context.shape,
       participant = hints.participant;
42095
   // both shape.create and elements.create must be handled
   if (process && (!participant || shape === participant)) {
42098
     // monkey-patch process ref
     getBusinessObject(shape).set('processRef', getBusinessObject(process));
   }
 }, true);
42103
 this.revert('shape.create', function(context) {
   var hints = context.hints || {},
       process = context.process || hints.process,
       processRef = context.processRef || hints.processRef,
       shape = context.shape,
       participant = hints.participant;
42110
   // both shape.create and elements.create must be handled
   if (process && (!participant || shape === participant)) {
42113
     // monkey-patch process ref
     getBusinessObject(shape).set('processRef', processRef);
   }
 }, true);
42118
 this.postExecute('shape.create', function(context) {
   var hints = context.hints || {},
       process = context.process || context.hints.process,
       shape = context.shape,
       participant = hints.participant;
42124
   if (process) {
     var children = process.children.slice();
42127
     // both shape.create and elements.create must be handled
     if (!participant) {
       modeling.moveElements(children, { x: 0, y: 0 }, shape);
     } else if (shape === participant) {
       modeling.moveElements(children, { x: 0, y: 0 }, participant);
     }
   }
 }, true);
}
42137
CreateParticipantBehavior.$inject = [
 'canvas',
 'eventBus',
 'modeling'
];
42143
inherits$1(CreateParticipantBehavior, CommandInterceptor);
42145
// helpers //////////
42147
function getParticipantBounds(shape, childrenBBox) {
 childrenBBox = {
   width: childrenBBox.width + HORIZONTAL_PARTICIPANT_PADDING * 2 + PARTICIPANT_BORDER_WIDTH,
   height: childrenBBox.height + VERTICAL_PARTICIPANT_PADDING * 2
 };
42153
 var width = Math.max(shape.width, childrenBBox.width),
     height = Math.max(shape.height, childrenBBox.height);
42156
 return {
   x: -width / 2,
   y: -height / 2,
   width: width,
   height: height
 };
}
42164
function getParticipantCreateConstraints(shape, childrenBBox) {
 childrenBBox = asTRBL(childrenBBox);
42167
 return {
   bottom: childrenBBox.top + shape.height / 2 - VERTICAL_PARTICIPANT_PADDING,
   left: childrenBBox.right - shape.width / 2 + HORIZONTAL_PARTICIPANT_PADDING,
   top: childrenBBox.bottom - shape.height / 2 + VERTICAL_PARTICIPANT_PADDING,
   right: childrenBBox.left + shape.width / 2 - HORIZONTAL_PARTICIPANT_PADDING - PARTICIPANT_BORDER_WIDTH
 };
}
42175
function isConnection$9(element) {
 return !!element.waypoints;
}
42179
function findParticipant(elements) {
 return find(elements, function(element) {
   return is$1(element, 'bpmn:Participant');
 });
}
42185
var TARGET_REF_PLACEHOLDER_NAME = '__targetRef_placeholder';
42187
42188
/**
* This behavior makes sure we always set a fake
* DataInputAssociation#targetRef as demanded by the BPMN 2.0
* XSD schema.
*
* The reference is set to a bpmn:Property{ name: '__targetRef_placeholder' }
* which is created on the fly and cleaned up afterwards if not needed
* anymore.
*
* @param {EventBus} eventBus
* @param {BpmnFactory} bpmnFactory
*/
function DataInputAssociationBehavior(eventBus, bpmnFactory) {
42202
 CommandInterceptor.call(this, eventBus);
42204
42205
 this.executed([
   'connection.create',
   'connection.delete',
   'connection.move',
   'connection.reconnect'
 ], ifDataInputAssociation(fixTargetRef));
42212
 this.reverted([
   'connection.create',
   'connection.delete',
   'connection.move',
   'connection.reconnect'
 ], ifDataInputAssociation(fixTargetRef));
42219
42220
 function usesTargetRef(element, targetRef, removedConnection) {
42222
   var inputAssociations = element.get('dataInputAssociations');
42224
   return find(inputAssociations, function(association) {
     return association !== removedConnection &&
            association.targetRef === targetRef;
   });
 }
42230
 function getTargetRef(element, create) {
42232
   var properties = element.get('properties');
42234
   var targetRefProp = find(properties, function(p) {
     return p.name === TARGET_REF_PLACEHOLDER_NAME;
   });
42238
   if (!targetRefProp && create) {
     targetRefProp = bpmnFactory.create('bpmn:Property', {
       name: TARGET_REF_PLACEHOLDER_NAME
     });
42243
     add(properties, targetRefProp);
   }
42246
   return targetRefProp;
 }
42249
 function cleanupTargetRef(element, connection) {
42251
   var targetRefProp = getTargetRef(element);
42253
   if (!targetRefProp) {
     return;
   }
42257
   if (!usesTargetRef(element, targetRefProp, connection)) {
     remove(element.get('properties'), targetRefProp);
   }
 }
42262
 /**
  * Make sure targetRef is set to a valid property or
  * `null` if the connection is detached.
  *
  * @param {Event} event
  */
 function fixTargetRef(event) {
42270
   var context = event.context,
       connection = context.connection,
       connectionBo = connection.businessObject,
       target = connection.target,
       targetBo = target && target.businessObject,
       newTarget = context.newTarget,
       newTargetBo = newTarget && newTarget.businessObject,
       oldTarget = context.oldTarget || context.target,
       oldTargetBo = oldTarget && oldTarget.businessObject;
42280
   var dataAssociation = connection.businessObject,
       targetRefProp;
42283
   if (oldTargetBo && oldTargetBo !== targetBo) {
     cleanupTargetRef(oldTargetBo, connectionBo);
   }
42287
   if (newTargetBo && newTargetBo !== targetBo) {
     cleanupTargetRef(newTargetBo, connectionBo);
   }
42291
   if (targetBo) {
     targetRefProp = getTargetRef(targetBo, true);
     dataAssociation.targetRef = targetRefProp;
   } else {
     dataAssociation.targetRef = null;
   }
 }
}
42300
DataInputAssociationBehavior.$inject = [
 'eventBus',
 'bpmnFactory'
];
42305
inherits$1(DataInputAssociationBehavior, CommandInterceptor);
42307
42308
/**
* Only call the given function when the event
* touches a bpmn:DataInputAssociation.
*
* @param {Function} fn
* @return {Function}
*/
function ifDataInputAssociation(fn) {
42317
 return function(event) {
   var context = event.context,
       connection = context.connection;
42321
   if (is$1(connection, 'bpmn:DataInputAssociation')) {
     return fn(event);
   }
 };
}
42327
function UpdateSemanticParentHandler(bpmnUpdater) {
 this._bpmnUpdater = bpmnUpdater;
}
42331
UpdateSemanticParentHandler.$inject = [ 'bpmnUpdater' ];
42333
42334
UpdateSemanticParentHandler.prototype.execute = function(context) {
 var dataStoreBo = context.dataStoreBo,
     dataStoreDi = context.dataStoreDi,
     newSemanticParent = context.newSemanticParent,
     newDiParent = context.newDiParent;
42340
 context.oldSemanticParent = dataStoreBo.$parent;
 context.oldDiParent = dataStoreDi.$parent;
42343
 // update semantic parent
 this._bpmnUpdater.updateSemanticParent(dataStoreBo, newSemanticParent);
42346
 // update DI parent
 this._bpmnUpdater.updateDiParent(dataStoreDi, newDiParent);
};
42350
UpdateSemanticParentHandler.prototype.revert = function(context) {
 var dataStoreBo = context.dataStoreBo,
     dataStoreDi = context.dataStoreDi,
     oldSemanticParent = context.oldSemanticParent,
     oldDiParent = context.oldDiParent;
42356
 // update semantic parent
 this._bpmnUpdater.updateSemanticParent(dataStoreBo, oldSemanticParent);
42359
 // update DI parent
 this._bpmnUpdater.updateDiParent(dataStoreDi, oldDiParent);
};
42363
/**
* BPMN specific data store behavior
*/
function DataStoreBehavior(
   canvas, commandStack, elementRegistry,
   eventBus) {
42370
 CommandInterceptor.call(this, eventBus);
42372
 commandStack.registerHandler('dataStore.updateContainment', UpdateSemanticParentHandler);
42374
 function getFirstParticipantWithProcessRef() {
   return elementRegistry.filter(function(element) {
     return is$1(element, 'bpmn:Participant') && getBusinessObject(element).processRef;
   })[0];
 }
42380
 function getDataStores(element) {
   return element.children.filter(function(child) {
     return is$1(child, 'bpmn:DataStoreReference') && !child.labelTarget;
   });
 }
42386
 function updateDataStoreParent(dataStore, newDataStoreParent) {
   var dataStoreBo = dataStore.businessObject || dataStore;
42389
   newDataStoreParent = newDataStoreParent || getFirstParticipantWithProcessRef();
42391
   if (newDataStoreParent) {
     var newDataStoreParentBo = newDataStoreParent.businessObject || newDataStoreParent;
42394
     commandStack.execute('dataStore.updateContainment', {
       dataStoreBo: dataStoreBo,
       dataStoreDi: getDi(dataStore),
       newSemanticParent: newDataStoreParentBo.processRef || newDataStoreParentBo,
       newDiParent: getDi(newDataStoreParent)
     });
   }
 }
42403
42404
 // disable auto-resize for data stores
 this.preExecute('shape.create', function(event) {
42407
   var context = event.context,
       shape = context.shape;
42410
   if (is$1(shape, 'bpmn:DataStoreReference') &&
       shape.type !== 'label') {
42413
     if (!context.hints) {
       context.hints = {};
     }
42417
     // prevent auto resizing
     context.hints.autoResize = false;
   }
 });
42422
42423
 // disable auto-resize for data stores
 this.preExecute('elements.move', function(event) {
   var context = event.context,
       shapes = context.shapes;
42428
   var dataStoreReferences = shapes.filter(function(shape) {
     return is$1(shape, 'bpmn:DataStoreReference');
   });
42432
   if (dataStoreReferences.length) {
     if (!context.hints) {
       context.hints = {};
     }
42437
     // prevent auto resizing for data store references
     context.hints.autoResize = shapes.filter(function(shape) {
       return !is$1(shape, 'bpmn:DataStoreReference');
     });
   }
 });
42444
42445
 // update parent on data store created
 this.postExecute('shape.create', function(event) {
   var context = event.context,
       shape = context.shape,
       parent = shape.parent;
42451
42452
   if (is$1(shape, 'bpmn:DataStoreReference') &&
       shape.type !== 'label' &&
       is$1(parent, 'bpmn:Collaboration')) {
42456
     updateDataStoreParent(shape);
   }
 });
42460
42461
 // update parent on data store moved
 this.postExecute('shape.move', function(event) {
   var context = event.context,
       shape = context.shape,
       oldParent = context.oldParent,
       parent = shape.parent;
42468
   if (is$1(oldParent, 'bpmn:Collaboration')) {
42470
     // do nothing if not necessary
     return;
   }
42474
   if (is$1(shape, 'bpmn:DataStoreReference') &&
       shape.type !== 'label' &&
       is$1(parent, 'bpmn:Collaboration')) {
42478
     var participant = is$1(oldParent, 'bpmn:Participant') ?
       oldParent :
       getAncestor(oldParent, 'bpmn:Participant');
42482
     updateDataStoreParent(shape, participant);
   }
 });
42486
42487
 // update data store parents on participant or subprocess deleted
 this.postExecute('shape.delete', function(event) {
   var context = event.context,
       shape = context.shape,
       rootElement = canvas.getRootElement();
42493
   if (isAny(shape, [ 'bpmn:Participant', 'bpmn:SubProcess' ])
       && is$1(rootElement, 'bpmn:Collaboration')) {
     getDataStores(rootElement)
       .filter(function(dataStore) {
         return isDescendant(dataStore, shape);
       })
       .forEach(function(dataStore) {
         updateDataStoreParent(dataStore);
       });
   }
 });
42505
 // update data store parents on collaboration -> process
 this.postExecute('canvas.updateRoot', function(event) {
   var context = event.context,
       oldRoot = context.oldRoot,
       newRoot = context.newRoot;
42511
   var dataStores = getDataStores(oldRoot);
42513
   dataStores.forEach(function(dataStore) {
42515
     if (is$1(newRoot, 'bpmn:Process')) {
       updateDataStoreParent(dataStore, newRoot);
     }
42519
   });
 });
}
42523
DataStoreBehavior.$inject = [
 'canvas',
 'commandStack',
 'elementRegistry',
 'eventBus',
];
42530
inherits$1(DataStoreBehavior, CommandInterceptor);
42532
42533
// helpers //////////
42535
function isDescendant(descendant, ancestor) {
 var descendantBo = descendant.businessObject || descendant,
     ancestorBo = ancestor.businessObject || ancestor;
42539
 while (descendantBo.$parent) {
   if (descendantBo.$parent === ancestorBo.processRef || ancestorBo) {
     return true;
   }
42544
   descendantBo = descendantBo.$parent;
 }
42547
 return false;
}
42550
function getAncestor(element, type) {
42552
 while (element.parent) {
   if (is$1(element.parent, type)) {
     return element.parent;
   }
42557
   element = element.parent;
 }
}
42561
var LOW_PRIORITY$c = 500;
42563
42564
/**
* BPMN specific delete lane behavior
*/
function DeleteLaneBehavior(eventBus, modeling, spaceTool) {
42569
 CommandInterceptor.call(this, eventBus);
42571
42572
 function compensateLaneDelete(shape, oldParent) {
42574
   var siblings = getChildLanes(oldParent);
42576
   var topAffected = [];
   var bottomAffected = [];
42579
   eachElement(siblings, function(element) {
42581
     if (element.y > shape.y) {
       bottomAffected.push(element);
     } else {
       topAffected.push(element);
     }
42587
     return element.children;
   });
42590
   if (!siblings.length) {
     return;
   }
42594
   var offset;
42596
   if (bottomAffected.length && topAffected.length) {
     offset = shape.height / 2;
   } else {
     offset = shape.height;
   }
42602
   var topAdjustments,
       bottomAdjustments;
42605
   if (topAffected.length) {
     topAdjustments = spaceTool.calculateAdjustments(
       topAffected, 'y', offset, shape.y - 10);
42609
     spaceTool.makeSpace(
       topAdjustments.movingShapes,
       topAdjustments.resizingShapes,
       { x: 0, y: offset }, 's');
   }
42615
   if (bottomAffected.length) {
     bottomAdjustments = spaceTool.calculateAdjustments(
       bottomAffected, 'y', -offset, shape.y + shape.height + 10);
42619
     spaceTool.makeSpace(
       bottomAdjustments.movingShapes,
       bottomAdjustments.resizingShapes,
       { x: 0, y: -offset }, 'n');
   }
 }
42626
42627
 /**
  * Adjust sizes of other lanes after lane deletion
  */
 this.postExecuted('shape.delete', LOW_PRIORITY$c, function(event) {
42632
   var context = event.context,
       hints = context.hints,
       shape = context.shape,
       oldParent = context.oldParent;
42637
   // only compensate lane deletes
   if (!is$1(shape, 'bpmn:Lane')) {
     return;
   }
42642
   // compensate root deletes only
   if (hints && hints.nested) {
     return;
   }
42647
   compensateLaneDelete(shape, oldParent);
 });
}
42651
DeleteLaneBehavior.$inject = [
 'eventBus',
 'modeling',
 'spaceTool'
];
42657
inherits$1(DeleteLaneBehavior, CommandInterceptor);
42659
var LOW_PRIORITY$b = 500;
42661
42662
/**
* Replace boundary event with intermediate event when creating or moving results in detached event.
*/
function DetachEventBehavior(bpmnReplace, injector) {
 injector.invoke(CommandInterceptor, this);
42668
 this._bpmnReplace = bpmnReplace;
42670
 var self = this;
42672
 this.postExecuted('elements.create', LOW_PRIORITY$b, function(context) {
   var elements = context.elements;
42675
   elements.filter(function(shape) {
     var host = shape.host;
42678
     return shouldReplace(shape, host);
   }).map(function(shape) {
     return elements.indexOf(shape);
   }).forEach(function(index) {
     context.elements[ index ] = self.replaceShape(elements[ index ]);
   });
 }, true);
42686
 this.preExecute('elements.move', LOW_PRIORITY$b, function(context) {
   var shapes = context.shapes,
       newHost = context.newHost;
42690
   shapes.forEach(function(shape, index) {
     var host = shape.host;
42693
     if (shouldReplace(shape, includes$6(shapes, host) ? host : newHost)) {
       shapes[ index ] = self.replaceShape(shape);
     }
   });
 }, true);
}
42700
DetachEventBehavior.$inject = [
 'bpmnReplace',
 'injector'
];
42705
inherits$1(DetachEventBehavior, CommandInterceptor);
42707
DetachEventBehavior.prototype.replaceShape = function(shape) {
 var eventDefinition = getEventDefinition(shape),
     intermediateEvent;
42711
 if (eventDefinition) {
   intermediateEvent = {
     type: 'bpmn:IntermediateCatchEvent',
     eventDefinitionType: eventDefinition.$type
   };
 } else {
   intermediateEvent = {
     type: 'bpmn:IntermediateThrowEvent'
   };
 }
42722
 return this._bpmnReplace.replaceElement(shape, intermediateEvent, { layoutConnection: false });
};
42725
42726
// helpers //////////
42728
function getEventDefinition(element) {
 var businessObject = getBusinessObject(element),
     eventDefinitions = businessObject.eventDefinitions;
42732
 return eventDefinitions && eventDefinitions[0];
}
42735
function shouldReplace(shape, host) {
 return !isLabel$6(shape) && is$1(shape, 'bpmn:BoundaryEvent') && !host;
}
42739
function includes$6(array, item) {
 return array.indexOf(item) !== -1;
}
42743
function DropOnFlowBehavior(eventBus, bpmnRules, modeling) {
42745
 CommandInterceptor.call(this, eventBus);
42747
 /**
  * Reconnect start / end of a connection after
  * dropping an element on a flow.
  */
42752
 function insertShape(shape, targetFlow, positionOrBounds) {
   var waypoints = targetFlow.waypoints,
       waypointsBefore,
       waypointsAfter,
       dockingPoint,
       source,
       target,
       incomingConnection,
       outgoingConnection,
       oldOutgoing = shape.outgoing.slice(),
       oldIncoming = shape.incoming.slice();
42764
   var mid;
42766
   if (isNumber(positionOrBounds.width)) {
     mid = getMid(positionOrBounds);
   } else {
     mid = positionOrBounds;
   }
42772
   var intersection = getApproxIntersection(waypoints, mid);
42774
   if (intersection) {
     waypointsBefore = waypoints.slice(0, intersection.index);
     waypointsAfter = waypoints.slice(intersection.index + (intersection.bendpoint ? 1 : 0));
42778
     // due to inaccuracy intersection might have been found
     if (!waypointsBefore.length || !waypointsAfter.length) {
       return;
     }
42783
     dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : mid;
42785
     // if last waypointBefore is inside shape's bounds, ignore docking point
     if (waypointsBefore.length === 1 || !isPointInsideBBox(shape, waypointsBefore[waypointsBefore.length-1])) {
       waypointsBefore.push(copy(dockingPoint));
     }
42790
     // if first waypointAfter is inside shape's bounds, ignore docking point
     if (waypointsAfter.length === 1 || !isPointInsideBBox(shape, waypointsAfter[0])) {
       waypointsAfter.unshift(copy(dockingPoint));
     }
   }
42796
   source = targetFlow.source;
   target = targetFlow.target;
42799
   if (bpmnRules.canConnect(source, shape, targetFlow)) {
42801
     // reconnect source -> inserted shape
     modeling.reconnectEnd(targetFlow, shape, waypointsBefore || mid);
42804
     incomingConnection = targetFlow;
   }
42807
   if (bpmnRules.canConnect(shape, target, targetFlow)) {
42809
     if (!incomingConnection) {
42811
       // reconnect inserted shape -> end
       modeling.reconnectStart(targetFlow, shape, waypointsAfter || mid);
42814
       outgoingConnection = targetFlow;
     } else {
       outgoingConnection = modeling.connect(
         shape, target, { type: targetFlow.type, waypoints: waypointsAfter }
       );
     }
   }
42822
   var duplicateConnections = [].concat(
42824
     incomingConnection && filter(oldIncoming, function(connection) {
       return connection.source === incomingConnection.source;
     }) || [],
42828
     outgoingConnection && filter(oldOutgoing, function(connection) {
       return connection.target === outgoingConnection.target;
     }) || []
   );
42833
   if (duplicateConnections.length) {
     modeling.removeElements(duplicateConnections);
   }
 }
42838
 this.preExecute('elements.move', function(context) {
42840
   var newParent = context.newParent,
       shapes = context.shapes,
       delta = context.delta,
       shape = shapes[0];
42845
   if (!shape || !newParent) {
     return;
   }
42849
   // if the new parent is a connection,
   // change it to the new parent's parent
   if (newParent && newParent.waypoints) {
     context.newParent = newParent = newParent.parent;
   }
42855
   var shapeMid = getMid(shape);
   var newShapeMid = {
     x: shapeMid.x + delta.x,
     y: shapeMid.y + delta.y
   };
42861
   // find a connection which intersects with the
   // element's mid point
   var connection = find(newParent.children, function(element) {
     var canInsert = bpmnRules.canInsert(shapes, element);
42866
     return canInsert && getApproxIntersection(element.waypoints, newShapeMid);
   });
42869
   if (connection) {
     context.targetFlow = connection;
     context.position = newShapeMid;
   }
42874
 }, true);
42876
 this.postExecuted('elements.move', function(context) {
42878
   var shapes = context.shapes,
       targetFlow = context.targetFlow,
       position = context.position;
42882
   if (targetFlow) {
     insertShape(shapes[0], targetFlow, position);
   }
42886
 }, true);
42888
 this.preExecute('shape.create', function(context) {
42890
   var parent = context.parent,
       shape = context.shape;
42893
   if (bpmnRules.canInsert(shape, parent)) {
     context.targetFlow = parent;
     context.parent = parent.parent;
   }
 }, true);
42899
 this.postExecuted('shape.create', function(context) {
42901
   var shape = context.shape,
       targetFlow = context.targetFlow,
       positionOrBounds = context.position;
42905
   if (targetFlow) {
     insertShape(shape, targetFlow, positionOrBounds);
   }
 }, true);
}
42911
inherits$1(DropOnFlowBehavior, CommandInterceptor);
42913
DropOnFlowBehavior.$inject = [
 'eventBus',
 'bpmnRules',
 'modeling'
];
42919
42920
// helpers /////////////////////
42922
function isPointInsideBBox(bbox, point) {
 var x = point.x,
     y = point.y;
42926
 return x >= bbox.x &&
   x <= bbox.x + bbox.width &&
   y >= bbox.y &&
   y <= bbox.y + bbox.height;
}
42932
function copy(obj) {
 return assign({}, obj);
}
42936
function EventBasedGatewayBehavior(eventBus, modeling) {
42938
 CommandInterceptor.call(this, eventBus);
42940
 /**
  * Remove existing sequence flows of event-based target before connecting
  * from event-based gateway.
  */
 this.preExecuted('connection.create', function(event) {
42946
   var context = event.context,
       source = context.source,
       target = context.target,
       existingIncomingConnections = target.incoming.slice();
42951
   if (context.hints && context.hints.createElementsBehavior === false) {
     return;
   }
42955
   if (
     is$1(source, 'bpmn:EventBasedGateway') &&
     target.incoming.length
   ) {
42960
     existingIncomingConnections.filter(isSequenceFlow)
       .forEach(function(sequenceFlow) {
         modeling.removeConnection(sequenceFlow);
       });
   }
 });
42967
 /**
  *  After replacing shape with event-based gateway, remove incoming sequence
  *  flows of event-based targets which do not belong to event-based gateway
  *  source.
  */
 this.preExecuted('shape.replace', function(event) {
42974
   var newShape = event.context.newShape,
       newShapeTargets,
       newShapeTargetsIncomingSequenceFlows;
42978
   if (!is$1(newShape, 'bpmn:EventBasedGateway')) {
     return;
   }
42982
   newShapeTargets = newShape.outgoing.filter(isSequenceFlow)
     .map(function(sequenceFlow) {
       return sequenceFlow.target;
     });
42987
   newShapeTargetsIncomingSequenceFlows = newShapeTargets.reduce(function(sequenceFlows, target) {
     var incomingSequenceFlows = target.incoming.filter(isSequenceFlow);
42990
     return sequenceFlows.concat(incomingSequenceFlows);
   }, []);
42993
   newShapeTargetsIncomingSequenceFlows.forEach(function(sequenceFlow) {
     if (sequenceFlow.source !== newShape) {
       modeling.removeConnection(sequenceFlow);
     }
   });
 });
}
43001
EventBasedGatewayBehavior.$inject = [
 'eventBus',
 'modeling'
];
43006
inherits$1(EventBasedGatewayBehavior, CommandInterceptor);
43008
43009
43010
// helpers //////////////////////
43012
function isSequenceFlow(connection) {
 return is$1(connection, 'bpmn:SequenceFlow');
}
43016
var HIGH_PRIORITY$b = 1500;
var HIGHEST_PRIORITY = 2000;
43019
43020
/**
* Correct hover targets in certain situations to improve diagram interaction.
*
* @param {ElementRegistry} elementRegistry
* @param {EventBus} eventBus
* @param {Canvas} canvas
*/
function FixHoverBehavior(elementRegistry, eventBus, canvas) {
43029
 eventBus.on([
   'create.hover',
   'create.move',
   'create.out',
   'create.end',
   'shape.move.hover',
   'shape.move.move',
   'shape.move.out',
   'shape.move.end'
 ], HIGH_PRIORITY$b, function(event) {
   var context = event.context,
       shape = context.shape || event.shape,
       hover = event.hover;
43043
   // ensure elements are not dropped onto a bpmn:Lane but onto
   // the underlying bpmn:Participant
   if (is$1(hover, 'bpmn:Lane') && !isAny(shape, [ 'bpmn:Lane', 'bpmn:Participant' ])) {
     event.hover = getLanesRoot(hover);
     event.hoverGfx = elementRegistry.getGraphics(event.hover);
   }
43050
   var rootElement = canvas.getRootElement();
43052
   // ensure bpmn:Group and label elements are dropped
   // always onto the root
   if (hover !== rootElement && (shape.labelTarget || is$1(shape, 'bpmn:Group'))) {
     event.hover = rootElement;
     event.hoverGfx = elementRegistry.getGraphics(event.hover);
   }
 });
43060
 eventBus.on([
   'connect.hover',
   'connect.out',
   'connect.end',
   'connect.cleanup',
   'global-connect.hover',
   'global-connect.out',
   'global-connect.end',
   'global-connect.cleanup'
 ], HIGH_PRIORITY$b, function(event) {
   var hover = event.hover;
43072
   // ensure connections start/end on bpmn:Participant,
   // not the underlying bpmn:Lane
   if (is$1(hover, 'bpmn:Lane')) {
     event.hover = getLanesRoot(hover) || hover;
     event.hoverGfx = elementRegistry.getGraphics(event.hover);
   }
 });
43080
43081
 eventBus.on([
   'bendpoint.move.hover'
 ], HIGH_PRIORITY$b, function(event) {
   var context = event.context,
       hover = event.hover,
       type = context.type;
43088
   // ensure reconnect start/end on bpmn:Participant,
   // not the underlying bpmn:Lane
   if (is$1(hover, 'bpmn:Lane') && /reconnect/.test(type)) {
     event.hover = getLanesRoot(hover) || hover;
     event.hoverGfx = elementRegistry.getGraphics(event.hover);
   }
 });
43096
43097
 eventBus.on([
   'connect.start'
 ], HIGH_PRIORITY$b, function(event) {
   var context = event.context,
       start = context.start;
43103
   // ensure connect start on bpmn:Participant,
   // not the underlying bpmn:Lane
   if (is$1(start, 'bpmn:Lane')) {
     context.start = getLanesRoot(start) || start;
   }
 });
43110
43111
 // allow movement of participants from lanes
 eventBus.on('shape.move.start', HIGHEST_PRIORITY, function(event) {
   var shape = event.shape;
43115
   if (is$1(shape, 'bpmn:Lane')) {
     event.shape = getLanesRoot(shape) || shape;
   }
 });
43120
}
43122
FixHoverBehavior.$inject = [
 'elementRegistry',
 'eventBus',
 'canvas'
];
43128
var HIGH_PRIORITY$a = 2000;
43130
43131
/**
* BPMN specific Group behavior
*/
function GroupBehavior(
   bpmnFactory,
   bpmnjs,
   elementRegistry,
   eventBus,
   injector,
   moddleCopy
) {
 injector.invoke(CommandInterceptor, this);
43144
 /**
  * Removes a referenced category value for a given group shape
  *
  * @param {djs.model.Shape} shape
  */
 function removeReferencedCategoryValue(shape) {
43151
   var businessObject = getBusinessObject(shape),
       categoryValue = businessObject.categoryValueRef;
43154
   if (!categoryValue) {
     return;
   }
43158
   var category = categoryValue.$parent;
43160
   if (!categoryValue) {
     return;
   }
43164
   remove(category.categoryValue, categoryValue);
43166
   // cleanup category if it is empty
   if (category && !category.categoryValue.length) {
     removeCategory(category);
   }
 }
43172
 /**
  * Removes a given category from the definitions
  *
  * @param {ModdleElement} category
  */
 function removeCategory(category) {
43179
   var definitions = bpmnjs.getDefinitions();
43181
   remove(definitions.get('rootElements'), category);
 }
43184
 /**
  * Returns all group element in the current registry
  *
  * @return {Array<djs.model.shape>} a list of group shapes
  */
 function getGroupElements() {
   return elementRegistry.filter(function(e) {
     return is$1(e, 'bpmn:Group');
   });
 }
43195
 /**
  * Returns true if given categoryValue is referenced in one of the given elements
  *
  * @param {Array<djs.model.shape>} elements
  * @param {ModdleElement} categoryValue
  * @return {boolean}
  */
 function isReferenced(elements, categoryValue) {
   return elements.some(function(e) {
43205
     var businessObject = getBusinessObject(e);
43207
     return businessObject.categoryValueRef
       && businessObject.categoryValueRef === categoryValue;
   });
 }
43212
 /**
  * remove referenced category + value when group was deleted
  */
 this.executed('shape.delete', function(event) {
43217
   var context = event.context,
       shape = context.shape;
43220
   if (is$1(shape, 'bpmn:Group')) {
43222
     var businessObject = getBusinessObject(shape),
         categoryValueRef = businessObject.categoryValueRef,
         groupElements = getGroupElements();
43226
     if (!isReferenced(groupElements, categoryValueRef)) {
       removeReferencedCategoryValue(shape);
     }
   }
 });
43232
 /**
  * re-attach removed category
  */
 this.reverted('shape.delete', function(event) {
43237
   var context = event.context,
       shape = context.shape;
43240
   if (is$1(shape, 'bpmn:Group')) {
43242
     var businessObject = getBusinessObject(shape),
         categoryValueRef = businessObject.categoryValueRef,
         definitions = bpmnjs.getDefinitions(),
         category = categoryValueRef ? categoryValueRef.$parent : null;
43247
     add(category.get('categoryValue'), categoryValueRef);
     add(definitions.get('rootElements'), category);
   }
 });
43252
 /**
  * create new category + value when group was created
  */
 this.execute('shape.create', function(event) {
   var context = event.context,
       shape = context.shape,
       businessObject = getBusinessObject(shape);
43260
   if (is$1(businessObject, 'bpmn:Group') && !businessObject.categoryValueRef) {
43262
     var definitions = bpmnjs.getDefinitions(),
         categoryValue = createCategoryValue(definitions, bpmnFactory);
43265
     // link the reference to the Group
     businessObject.categoryValueRef = categoryValue;
   }
 });
43270
43271
 this.revert('shape.create', function(event) {
43273
   var context = event.context,
       shape = context.shape;
43276
   if (is$1(shape, 'bpmn:Group')) {
     removeReferencedCategoryValue(shape);
43279
     delete getBusinessObject(shape).categoryValueRef;
43281
   }
 });
43284
 // copy bpmn:CategoryValue when copying element
 eventBus.on('moddleCopy.canCopyProperty', HIGH_PRIORITY$a, function(context) {
   var property = context.property,
       categoryValue;
43289
   if (is$1(property, 'bpmn:CategoryValue')) {
     categoryValue = createCategoryValue(bpmnjs.getDefinitions(), bpmnFactory);
43292
     // return copy of category
     return moddleCopy.copyElement(property, categoryValue);
   }
 });
43297
}
43299
GroupBehavior.$inject = [
 'bpmnFactory',
 'bpmnjs',
 'elementRegistry',
 'eventBus',
 'injector',
 'moddleCopy'
];
43308
inherits$1(GroupBehavior, CommandInterceptor);
43310
/**
* Returns the intersection between two line segments a and b.
*
* @param {Point} l1s
* @param {Point} l1e
* @param {Point} l2s
* @param {Point} l2e
*
* @return {Point}
*/
function lineIntersect(l1s, l1e, l2s, l2e) {
43322
 // if the lines intersect, the result contains the x and y of the
 // intersection (treating the lines as infinite) and booleans for
 // whether line segment 1 or line segment 2 contain the point
 var denominator, a, b, c, numerator;
43327
 denominator = ((l2e.y - l2s.y) * (l1e.x - l1s.x)) - ((l2e.x - l2s.x) * (l1e.y - l1s.y));
43329
 if (denominator == 0) {
   return null;
 }
43333
 a = l1s.y - l2s.y;
 b = l1s.x - l2s.x;
 numerator = ((l2e.x - l2s.x) * a) - ((l2e.y - l2s.y) * b);
43337
 c = numerator / denominator;
43339
 // if we cast these lines infinitely in
 // both directions, they intersect here
 return {
   x: Math.round(l1s.x + (c * (l1e.x - l1s.x))),
   y: Math.round(l1s.y + (c * (l1e.y - l1s.y)))
 };
}
43347
/**
* Fix broken dockings after DI imports.
*
* @param {EventBus} eventBus
*/
function ImportDockingFix(eventBus) {
43354
 function adjustDocking(startPoint, nextPoint, elementMid) {
43356
   var elementTop = {
     x: elementMid.x,
     y: elementMid.y - 50
   };
43361
   var elementLeft = {
     x: elementMid.x - 50,
     y: elementMid.y
   };
43366
   var verticalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementTop),
       horizontalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementLeft);
43369
   // original is horizontal or vertical center cross intersection
   var centerIntersect;
43372
   if (verticalIntersect && horizontalIntersect) {
     if (getDistance$1(verticalIntersect, elementMid) > getDistance$1(horizontalIntersect, elementMid)) {
       centerIntersect = horizontalIntersect;
     } else {
       centerIntersect = verticalIntersect;
     }
   } else {
     centerIntersect = verticalIntersect || horizontalIntersect;
   }
43382
   startPoint.original = centerIntersect;
 }
43385
 function fixDockings(connection) {
   var waypoints = connection.waypoints;
43388
   adjustDocking(
     waypoints[0],
     waypoints[1],
     getMid(connection.source)
   );
43394
   adjustDocking(
     waypoints[waypoints.length - 1],
     waypoints[waypoints.length - 2],
     getMid(connection.target)
   );
 }
43401
 eventBus.on('bpmnElement.added', function(e) {
43403
   var element = e.element;
43405
   if (element.waypoints) {
     fixDockings(element);
   }
 });
}
43411
ImportDockingFix.$inject = [
 'eventBus'
];
43415
43416
// helpers //////////////////////
43418
function getDistance$1(p1, p2) {
 return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
}
43422
/**
* A component that makes sure that each created or updated
* Pool and Lane is assigned an isHorizontal property set to true.
*
* @param {EventBus} eventBus
*/
function IsHorizontalFix(eventBus) {
43430
 CommandInterceptor.call(this, eventBus);
43432
 var elementTypesToUpdate = [
   'bpmn:Participant',
   'bpmn:Lane'
 ];
43437
 this.executed([ 'shape.move', 'shape.create', 'shape.resize' ], function(event) {
   var shape = event.context.shape,
       bo = getBusinessObject(shape),
       di = getDi(shape);
43442
   if (isAny(bo, elementTypesToUpdate) && !di.get('isHorizontal')) {
43444
     // set attribute directly to avoid modeling#updateProperty side effects
     di.set('isHorizontal', true);
   }
 });
43449
}
43451
IsHorizontalFix.$inject = [ 'eventBus' ];
43453
inherits$1(IsHorizontalFix, CommandInterceptor);
43455
/**
* Returns the length of a vector
*
* @param {Vector}
* @return {Float}
*/
function vectorLength(v) {
 return Math.sqrt(Math.pow(v.x, 2) + Math.pow(v.y, 2));
}
43465
43466
/**
* Calculates the angle between a line a the yAxis
*
* @param {Array}
* @return {Float}
*/
function getAngle(line) {
43474
 // return value is between 0, 180 and -180, -0
 // @janstuemmel: maybe replace return a/b with b/a
 return Math.atan((line[1].y - line[0].y) / (line[1].x - line[0].x));
}
43479
43480
/**
* Rotates a vector by a given angle
*
* @param {Vector}
* @param {Float} Angle in radians
* @return {Vector}
*/
function rotateVector(vector, angle) {
 return (!angle) ? vector : {
   x: Math.cos(angle) * vector.x - Math.sin(angle) * vector.y,
   y: Math.sin(angle) * vector.x + Math.cos(angle) * vector.y
 };
}
43494
43495
/**
* Solves a 2D equation system
* a + r*b = c, where a,b,c are 2D vectors
*
* @param {Vector}
* @param {Vector}
* @param {Vector}
* @return {Float}
*/
function solveLambaSystem(a, b, c) {
43506
 // the 2d system
 var system = [
   { n: a[0] - c[0], lambda: b[0] },
   { n: a[1] - c[1], lambda: b[1] }
 ];
43512
 // solve
 var n = system[0].n * b[0] + system[1].n * b[1],
     l = system[0].lambda * b[0] + system[1].lambda * b[1];
43516
 return -n/l;
}
43519
43520
/**
* Position of perpendicular foot
*
* @param {Point}
* @param [ {Point}, {Point} ] line defined through two points
* @return {Point} the perpendicular foot position
*/
function perpendicularFoot(point, line) {
43529
 var a = line[0], b = line[1];
43531
 // relative position of b from a
 var bd = { x: b.x - a.x, y: b.y - a.y };
43534
 // solve equation system to the parametrized vectors param real value
 var r = solveLambaSystem([ a.x, a.y ], [ bd.x, bd.y ], [ point.x, point.y ]);
43537
 return { x: a.x + r*bd.x, y: a.y + r*bd.y };
}
43540
43541
/**
* Calculates the distance between a point and a line
*
* @param {Point}
* @param [ {Point}, {Point} ] line defined through two points
* @return {Float} distance
*/
function getDistancePointLine(point, line) {
43550
 var pfPoint = perpendicularFoot(point, line);
43552
 // distance vector
 var connectionVector = {
   x: pfPoint.x - point.x,
   y: pfPoint.y - point.y
 };
43558
 return vectorLength(connectionVector);
}
43561
43562
/**
* Calculates the distance between two points
*
* @param {Point}
* @param {Point}
* @return {Float} distance
*/
function getDistancePointPoint(point1, point2) {
43571
 return vectorLength({
   x: point1.x - point2.x,
   y: point1.y - point2.y
 });
}
43577
var sqrt = Math.sqrt,
   min$1 = Math.min,
   max$3 = Math.max,
   abs$3 = Math.abs;
43582
/**
* Calculate the square (power to two) of a number.
*
* @param {number} n
*
* @return {number}
*/
function sq(n) {
 return Math.pow(n, 2);
}
43593
/**
* Get distance between two points.
*
* @param {Point} p1
* @param {Point} p2
*
* @return {number}
*/
function getDistance(p1, p2) {
 return sqrt(sq(p1.x - p2.x) + sq(p1.y - p2.y));
}
43605
/**
* Return the attachment of the given point on the specified line.
*
* The attachment is either a bendpoint (attached to the given point)
* or segment (attached to a location on a line segment) attachment:
*
* ```javascript
* var pointAttachment = {
*   type: 'bendpoint',
*   bendpointIndex: 3,
*   position: { x: 10, y: 10 } // the attach point on the line
* };
*
* var segmentAttachment = {
*   type: 'segment',
*   segmentIndex: 2,
*   relativeLocation: 0.31, // attach point location between 0 (at start) and 1 (at end)
*   position: { x: 10, y: 10 } // the attach point on the line
* };
* ```
*
* @param {Point} point
* @param {Array<Point>} line
*
* @return {Object} attachment
*/
function getAttachment(point, line) {
43633
 var idx = 0,
     segmentStart,
     segmentEnd,
     segmentStartDistance,
     segmentEndDistance,
     attachmentPosition,
     minDistance,
     intersections,
     attachment,
     attachmentDistance,
     closestAttachmentDistance,
     closestAttachment;
43646
 for (idx = 0; idx < line.length - 1; idx++) {
43648
   segmentStart = line[idx];
   segmentEnd = line[idx + 1];
43651
   if (pointsEqual(segmentStart, segmentEnd)) {
     intersections = [ segmentStart ];
   } else {
     segmentStartDistance = getDistance(point, segmentStart);
     segmentEndDistance = getDistance(point, segmentEnd);
43657
     minDistance = min$1(segmentStartDistance, segmentEndDistance);
43659
     intersections = getCircleSegmentIntersections(segmentStart, segmentEnd, point, minDistance);
   }
43662
   if (intersections.length < 1) {
     throw new Error('expected between [1, 2] circle -> line intersections');
   }
43666
   // one intersection -> bendpoint attachment
   if (intersections.length === 1) {
     attachment = {
       type: 'bendpoint',
       position: intersections[0],
       segmentIndex: idx,
       bendpointIndex: pointsEqual(segmentStart, intersections[0]) ? idx : idx + 1
     };
   }
43676
   // two intersections -> segment attachment
   if (intersections.length === 2) {
43679
     attachmentPosition = mid$1(intersections[0], intersections[1]);
43681
     attachment = {
       type: 'segment',
       position: attachmentPosition,
       segmentIndex: idx,
       relativeLocation: getDistance(segmentStart, attachmentPosition) / getDistance(segmentStart, segmentEnd)
     };
   }
43689
   attachmentDistance = getDistance(attachment.position, point);
43691
   if (!closestAttachment || closestAttachmentDistance > attachmentDistance) {
     closestAttachment = attachment;
     closestAttachmentDistance = attachmentDistance;
   }
 }
43697
 return closestAttachment;
}
43700
/**
* Gets the intersection between a circle and a line segment.
*
* @param {Point} s1 segment start
* @param {Point} s2 segment end
* @param {Point} cc circle center
* @param {number} cr circle radius
*
* @return {Array<Point>} intersections
*/
function getCircleSegmentIntersections(s1, s2, cc, cr) {
43712
 var baX = s2.x - s1.x;
 var baY = s2.y - s1.y;
 var caX = cc.x - s1.x;
 var caY = cc.y - s1.y;
43717
 var a = baX * baX + baY * baY;
 var bBy2 = baX * caX + baY * caY;
 var c = caX * caX + caY * caY - cr * cr;
43721
 var pBy2 = bBy2 / a;
 var q = c / a;
43724
 var disc = pBy2 * pBy2 - q;
43726
 // check against negative value to work around
 // negative, very close to zero results (-4e-15)
 // being produced in some environments
 if (disc < 0 && disc > -0.000001) {
   disc = 0;
 }
43733
 if (disc < 0) {
   return [];
 }
43737
 // if disc == 0 ... dealt with later
 var tmpSqrt = sqrt(disc);
 var abScalingFactor1 = -pBy2 + tmpSqrt;
 var abScalingFactor2 = -pBy2 - tmpSqrt;
43742
 var i1 = {
   x: s1.x - baX * abScalingFactor1,
   y: s1.y - baY * abScalingFactor1
 };
43747
 if (disc === 0) { // abScalingFactor1 == abScalingFactor2
   return [ i1 ];
 }
43751
 var i2 = {
   x: s1.x - baX * abScalingFactor2,
   y: s1.y - baY * abScalingFactor2
 };
43756
 // return only points on line segment
 return [ i1, i2 ].filter(function(p) {
   return isPointInSegment(p, s1, s2);
 });
}
43762
43763
function isPointInSegment(p, segmentStart, segmentEnd) {
 return (
   fenced(p.x, segmentStart.x, segmentEnd.x) &&
   fenced(p.y, segmentStart.y, segmentEnd.y)
 );
}
43770
function fenced(n, rangeStart, rangeEnd) {
43772
 // use matching threshold to work around
 // precision errors in intersection computation
43775
 return (
   n >= min$1(rangeStart, rangeEnd) - EQUAL_THRESHOLD &&
   n <= max$3(rangeStart, rangeEnd) + EQUAL_THRESHOLD
 );
}
43781
/**
* Calculate mid of two points.
*
* @param {Point} p1
* @param {Point} p2
*
* @return {Point}
*/
function mid$1(p1, p2) {
43791
 return {
   x: (p1.x + p2.x) / 2,
   y: (p1.y + p2.y) / 2
 };
}
43797
var EQUAL_THRESHOLD = 0.1;
43799
function pointsEqual(p1, p2) {
43801
 return (
   abs$3(p1.x - p2.x) <= EQUAL_THRESHOLD &&
   abs$3(p1.y - p2.y) <= EQUAL_THRESHOLD
 );
}
43807
function findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints) {
43809
 var index = attachment.segmentIndex;
43811
 var offset = newWaypoints.length - oldWaypoints.length;
43813
 // segmentMove happened
 if (hints.segmentMove) {
43816
   var oldSegmentStartIndex = hints.segmentMove.segmentStartIndex,
       newSegmentStartIndex = hints.segmentMove.newSegmentStartIndex;
43819
   // if label was on moved segment return new segment index
   if (index === oldSegmentStartIndex) {
     return newSegmentStartIndex;
   }
43824
   // label is after new segment index
   if (index >= newSegmentStartIndex) {
     return (index+offset < newSegmentStartIndex) ? newSegmentStartIndex : index+offset;
   }
43829
   // if label is before new segment index
   return index;
 }
43833
 // bendpointMove happened
 if (hints.bendpointMove) {
43836
   var insert = hints.bendpointMove.insert,
       bendpointIndex = hints.bendpointMove.bendpointIndex,
       newIndex;
43840
   // waypoints length didnt change
   if (offset === 0) {
     return index;
   }
43845
   // label behind new/removed bendpoint
   if (index >= bendpointIndex) {
     newIndex = insert ? index + 1 : index - 1;
   }
43850
   // label before new/removed bendpoint
   if (index < bendpointIndex) {
43853
     newIndex = index;
43855
     // decide label should take right or left segment
     if (insert && attachment.type !== 'bendpoint' && bendpointIndex-1 === index) {
43858
       var rel = relativePositionMidWaypoint(newWaypoints, bendpointIndex);
43860
       if (rel < attachment.relativeLocation) {
         newIndex++;
       }
     }
   }
43866
   return newIndex;
 }
43869
 // start/end changed
 if (offset === 0) {
   return index;
 }
43874
 if (hints.connectionStart) {
   return (index === 0) ? 0 : null;
 }
43878
 if (hints.connectionEnd) {
   return (index === oldWaypoints.length - 2) ? newWaypoints.length - 2 : null;
 }
43882
 // if nothing fits, return null
 return null;
}
43886
43887
/**
* Calculate the required adjustment (move delta) for the given label
* after the connection waypoints got updated.
*
* @param {djs.model.Label} label
* @param {Array<Point>} newWaypoints
* @param {Array<Point>} oldWaypoints
* @param {Object} hints
*
* @return {Point} delta
*/
function getLabelAdjustment(label, newWaypoints, oldWaypoints, hints) {
43900
 var x = 0,
     y = 0;
43903
 var labelPosition = getLabelMid(label);
43905
 // get closest attachment
 var attachment = getAttachment(labelPosition, oldWaypoints),
     oldLabelLineIndex = attachment.segmentIndex,
     newLabelLineIndex = findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints);
43910
 if (newLabelLineIndex === null) {
   return { x: x, y: y };
 }
43914
 // should never happen
 // TODO(@janstuemmel): throw an error here when connectionSegmentMove is refactored
 if (newLabelLineIndex < 0 ||
     newLabelLineIndex > newWaypoints.length - 2) {
   return { x: x, y: y };
 }
43921
 var oldLabelLine = getLine(oldWaypoints, oldLabelLineIndex),
     newLabelLine = getLine(newWaypoints, newLabelLineIndex),
     oldFoot = attachment.position;
43925
 var relativeFootPosition = getRelativeFootPosition(oldLabelLine, oldFoot),
     angleDelta = getAngleDelta(oldLabelLine, newLabelLine);
43928
 // special rule if label on bendpoint
 if (attachment.type === 'bendpoint') {
43931
   var offset = newWaypoints.length - oldWaypoints.length,
       oldBendpointIndex = attachment.bendpointIndex,
       oldBendpoint = oldWaypoints[oldBendpointIndex];
43935
   // bendpoint position hasn't changed, return same position
   if (newWaypoints.indexOf(oldBendpoint) !== -1) {
     return { x: x, y: y };
   }
43940
   // new bendpoint and old bendpoint have same index, then just return the offset
   if (offset === 0) {
     var newBendpoint = newWaypoints[oldBendpointIndex];
43944
     return {
       x: newBendpoint.x - attachment.position.x,
       y: newBendpoint.y - attachment.position.y
     };
   }
43950
   // if bendpoints get removed
   if (offset < 0 && oldBendpointIndex !== 0 && oldBendpointIndex < oldWaypoints.length - 1) {
     relativeFootPosition = relativePositionMidWaypoint(oldWaypoints, oldBendpointIndex);
   }
 }
43956
 var newFoot = {
   x: (newLabelLine[1].x - newLabelLine[0].x) * relativeFootPosition + newLabelLine[0].x,
   y: (newLabelLine[1].y - newLabelLine[0].y) * relativeFootPosition + newLabelLine[0].y
 };
43961
 // the rotated vector to label
 var newLabelVector = rotateVector({
   x: labelPosition.x - oldFoot.x,
   y: labelPosition.y - oldFoot.y
 }, angleDelta);
43967
 // the new relative position
 x = newFoot.x + newLabelVector.x - labelPosition.x;
 y = newFoot.y + newLabelVector.y - labelPosition.y;
43971
 return roundPoint({
   x: x,
   y: y
 });
}
43977
43978
// HELPERS //////////////////////
43980
function relativePositionMidWaypoint(waypoints, idx) {
43982
 var distanceSegment1 = getDistancePointPoint(waypoints[idx-1], waypoints[idx]),
     distanceSegment2 = getDistancePointPoint(waypoints[idx], waypoints[idx+1]);
43985
 var relativePosition = distanceSegment1 / (distanceSegment1 + distanceSegment2);
43987
 return relativePosition;
}
43990
function getLabelMid(label) {
 return {
   x: label.x + label.width / 2,
   y: label.y + label.height / 2
 };
}
43997
function getAngleDelta(l1, l2) {
 var a1 = getAngle(l1),
     a2 = getAngle(l2);
 return a2 - a1;
}
44003
function getLine(waypoints, idx) {
 return [ waypoints[idx], waypoints[idx+1] ];
}
44007
function getRelativeFootPosition(line, foot) {
44009
 var length = getDistancePointPoint(line[0], line[1]),
     lengthToFoot = getDistancePointPoint(line[0], foot);
44012
 return length === 0 ? 0 : lengthToFoot / length;
}
44015
/**
* Calculates the absolute point relative to the new element's position
*
* @param {point} point [absolute]
* @param {bounds} oldBounds
* @param {bounds} newBounds
*
* @return {point} point [absolute]
*/
function getNewAttachPoint(point, oldBounds, newBounds) {
 var oldCenter = center(oldBounds),
     newCenter = center(newBounds),
     oldDelta = delta(point, oldCenter);
44029
 var newDelta = {
   x: oldDelta.x * (newBounds.width / oldBounds.width),
   y: oldDelta.y * (newBounds.height / oldBounds.height)
 };
44034
 return roundPoint({
   x: newCenter.x + newDelta.x,
   y: newCenter.y + newDelta.y
 });
}
44040
44041
/**
* Calculates the shape's delta relative to a new position
* of a certain element's bounds
*
* @param {djs.model.Shape} point [absolute]
* @param {bounds} oldBounds
* @param {bounds} newBounds
*
* @return {delta} delta
*/
function getNewAttachShapeDelta(shape, oldBounds, newBounds) {
 var shapeCenter = center(shape),
     oldCenter = center(oldBounds),
     newCenter = center(newBounds),
     shapeDelta = delta(shape, shapeCenter),
     oldCenterDelta = delta(shapeCenter, oldCenter),
     stickyPositionDelta = getStickyPositionDelta(shapeCenter, oldBounds, newBounds);
44059
 if (stickyPositionDelta) {
   return stickyPositionDelta;
 }
44063
 var newCenterDelta = {
   x: oldCenterDelta.x * (newBounds.width / oldBounds.width),
   y: oldCenterDelta.y * (newBounds.height / oldBounds.height)
 };
44068
 var newShapeCenter = {
   x: newCenter.x + newCenterDelta.x,
   y: newCenter.y + newCenterDelta.y
 };
44073
 return roundPoint({
   x: newShapeCenter.x + shapeDelta.x - shape.x,
   y: newShapeCenter.y + shapeDelta.y - shape.y
 });
}
44079
function getStickyPositionDelta(oldShapeCenter, oldBounds, newBounds) {
 var oldTRBL = asTRBL(oldBounds),
     newTRBL = asTRBL(newBounds);
44083
 if (isMoved(oldTRBL, newTRBL)) {
   return null;
 }
44087
 var oldOrientation = getOrientation(oldBounds, oldShapeCenter),
     stickyPositionDelta,
     newShapeCenter,
     newOrientation;
44092
 if (oldOrientation === 'top') {
   stickyPositionDelta = {
     x: 0,
     y: newTRBL.bottom - oldTRBL.bottom
   };
 } else if (oldOrientation === 'bottom') {
   stickyPositionDelta = {
     x: 0,
     y: newTRBL.top - oldTRBL.top
   };
 } else if (oldOrientation === 'right') {
   stickyPositionDelta = {
     x: newTRBL.left - oldTRBL.left,
     y: 0
   };
 } else if (oldOrientation === 'left') {
   stickyPositionDelta = {
     x: newTRBL.right - oldTRBL.right,
     y: 0
   };
 } else {
44114
   // fallback to proportional movement for corner-placed attachments
   return null;
 }
44118
 newShapeCenter = {
   x: oldShapeCenter.x + stickyPositionDelta.x,
   y: oldShapeCenter.y + stickyPositionDelta.y
 };
44123
 newOrientation = getOrientation(newBounds, newShapeCenter);
44125
 if (newOrientation !== oldOrientation) {
44127
   // fallback to proportional movement if orientation would otherwise change
   return null;
 }
44131
 return stickyPositionDelta;
}
44134
function isMoved(oldTRBL, newTRBL) {
 return isHorizontallyMoved(oldTRBL, newTRBL) || isVerticallyMoved(oldTRBL, newTRBL);
}
44138
function isHorizontallyMoved(oldTRBL, newTRBL) {
 return oldTRBL.right !== newTRBL.right && oldTRBL.left !== newTRBL.left;
}
44142
function isVerticallyMoved(oldTRBL, newTRBL) {
 return oldTRBL.top !== newTRBL.top && oldTRBL.bottom !== newTRBL.bottom;
}
44146
var DEFAULT_LABEL_DIMENSIONS = {
 width: 90,
 height: 20
};
44151
var NAME_PROPERTY = 'name';
var TEXT_PROPERTY = 'text';
44154
/**
* A component that makes sure that external labels are added
* together with respective elements and properly updated (DI wise)
* during move.
*
* @param {EventBus} eventBus
* @param {Modeling} modeling
* @param {BpmnFactory} bpmnFactory
* @param {TextRenderer} textRenderer
*/
function LabelBehavior(
   eventBus, modeling, bpmnFactory,
   textRenderer) {
44168
 CommandInterceptor.call(this, eventBus);
44170
 // update label if name property was updated
 this.postExecute('element.updateProperties', function(e) {
   var context = e.context,
       element = context.element,
       properties = context.properties;
44176
   if (NAME_PROPERTY in properties) {
     modeling.updateLabel(element, properties[NAME_PROPERTY]);
   }
44180
   if (TEXT_PROPERTY in properties
       && is$1(element, 'bpmn:TextAnnotation')) {
44183
     var newBounds = textRenderer.getTextAnnotationBounds(
       {
         x: element.x,
         y: element.y,
         width: element.width,
         height: element.height
       },
       properties[TEXT_PROPERTY] || ''
     );
44193
     modeling.updateLabel(element, properties.text, newBounds);
   }
 });
44197
 // create label shape after shape/connection was created
 this.postExecute([ 'shape.create', 'connection.create' ], function(e) {
   var context = e.context,
       hints = context.hints || {};
44202
   if (hints.createElementsBehavior === false) {
     return;
   }
44206
   var element = context.shape || context.connection,
       businessObject = element.businessObject;
44209
   if (isLabel$6(element) || !isLabelExternal(element)) {
     return;
   }
44213
   // only create label if attribute available
   if (!getLabel(element)) {
     return;
   }
44218
   var labelCenter = getExternalLabelMid(element);
44220
   // we don't care about x and y
   var labelDimensions = textRenderer.getExternalLabelBounds(
     DEFAULT_LABEL_DIMENSIONS,
     getLabel(element)
   );
44226
   modeling.createLabel(element, labelCenter, {
     id: businessObject.id + '_label',
     businessObject: businessObject,
     width: labelDimensions.width,
     height: labelDimensions.height
   });
 });
44234
 // update label after label shape was deleted
 this.postExecute('shape.delete', function(event) {
   var context = event.context,
       labelTarget = context.labelTarget,
       hints = context.hints || {};
44240
   // check if label
   if (labelTarget && hints.unsetLabel !== false) {
     modeling.updateLabel(labelTarget, null, null, { removeShape: false });
   }
 });
44246
 // update di information on label creation
 this.postExecute([ 'label.create' ], function(event) {
44249
   var context = event.context,
       element = context.shape,
       labelTarget = context.labelTarget,
       di;
44254
   // we want to trigger on real labels only
   if (!labelTarget) {
     return;
   }
44259
   // we want to trigger on BPMN elements only
   if (!is$1(labelTarget, 'bpmn:BaseElement')) {
     return;
   }
44264
   di = getDi(labelTarget);
44266
   if (!di.label) {
     di.label = bpmnFactory.create('bpmndi:BPMNLabel', {
       bounds: bpmnFactory.create('dc:Bounds')
     });
44271
     element.di = di;
   }
44274
   assign(di.label.bounds, {
     x: element.x,
     y: element.y,
     width: element.width,
     height: element.height
   });
 });
44282
 function getVisibleLabelAdjustment(event) {
44284
   var context = event.context,
       connection = context.connection,
       label = connection.label,
       hints = assign({}, context.hints),
       newWaypoints = context.newWaypoints || connection.waypoints,
       oldWaypoints = context.oldWaypoints;
44291
44292
   if (typeof hints.startChanged === 'undefined') {
     hints.startChanged = !!hints.connectionStart;
   }
44296
   if (typeof hints.endChanged === 'undefined') {
     hints.endChanged = !!hints.connectionEnd;
   }
44300
   return getLabelAdjustment(label, newWaypoints, oldWaypoints, hints);
 }
44303
 this.postExecute([
   'connection.layout',
   'connection.updateWaypoints'
 ], function(event) {
   var context = event.context,
       hints = context.hints || {};
44310
   if (hints.labelBehavior === false) {
     return;
   }
44314
   var connection = context.connection,
       label = connection.label,
       labelAdjustment;
44318
   // handle missing label as well as the case
   // that the label parent does not exist (yet),
   // because it is being pasted / created via multi element create
   //
   // Cf. https://github.com/bpmn-io/bpmn-js/pull/1227
   if (!label || !label.parent) {
     return;
   }
44327
   labelAdjustment = getVisibleLabelAdjustment(event);
44329
   modeling.moveShape(label, labelAdjustment);
 });
44332
44333
 // keep label position on shape replace
 this.postExecute([ 'shape.replace' ], function(event) {
   var context = event.context,
       newShape = context.newShape,
       oldShape = context.oldShape;
44339
   var businessObject = getBusinessObject(newShape);
44341
   if (businessObject
     && isLabelExternal(businessObject)
     && oldShape.label
     && newShape.label) {
     newShape.label.x = oldShape.label.x;
     newShape.label.y = oldShape.label.y;
   }
 });
44350
44351
 // move external label after resizing
 this.postExecute('shape.resize', function(event) {
44354
   var context = event.context,
       shape = context.shape,
       newBounds = context.newBounds,
       oldBounds = context.oldBounds;
44359
   if (hasExternalLabel(shape)) {
44361
     var label = shape.label,
         labelMid = getMid(label),
         edges = asEdges(oldBounds);
44365
     // get nearest border point to label as reference point
     var referencePoint = getReferencePoint(labelMid, edges);
44368
     var delta = getReferencePointDelta(referencePoint, oldBounds, newBounds);
44370
     modeling.moveShape(label, delta);
44372
   }
44374
 });
44376
}
44378
inherits$1(LabelBehavior, CommandInterceptor);
44380
LabelBehavior.$inject = [
 'eventBus',
 'modeling',
 'bpmnFactory',
 'textRenderer'
];
44387
// helpers //////////////////////
44389
/**
* Calculates a reference point delta relative to a new position
* of a certain element's bounds
*
* @param {Point} point
* @param {Bounds} oldBounds
* @param {Bounds} newBounds
*
* @return {Delta} delta
*/
function getReferencePointDelta(referencePoint, oldBounds, newBounds) {
44401
 var newReferencePoint = getNewAttachPoint(referencePoint, oldBounds, newBounds);
44403
 return roundPoint(delta(newReferencePoint, referencePoint));
}
44406
/**
* Generates the nearest point (reference point) for a given point
* onto given set of lines
*
* @param {Array<Point, Point>} lines
* @param {Point} point
*
* @param {Point}
*/
function getReferencePoint(point, lines) {
44417
 if (!lines.length) {
   return;
 }
44421
 var nearestLine = getNearestLine(point, lines);
44423
 return perpendicularFoot(point, nearestLine);
}
44426
/**
* Convert the given bounds to a lines array containing all edges
*
* @param {Bounds|Point} bounds
*
* @return Array<Point>
*/
function asEdges(bounds) {
 return [
   [ // top
     {
       x: bounds.x,
       y: bounds.y
     },
     {
       x: bounds.x + (bounds.width || 0),
       y: bounds.y
     }
   ],
   [ // right
     {
       x: bounds.x + (bounds.width || 0),
       y: bounds.y
     },
     {
       x: bounds.x + (bounds.width || 0),
       y: bounds.y + (bounds.height || 0)
     }
   ],
   [ // bottom
     {
       x: bounds.x,
       y: bounds.y + (bounds.height || 0)
     },
     {
       x: bounds.x + (bounds.width || 0),
       y: bounds.y + (bounds.height || 0)
     }
   ],
   [ // left
     {
       x: bounds.x,
       y: bounds.y
     },
     {
       x: bounds.x,
       y: bounds.y + (bounds.height || 0)
     }
   ]
 ];
}
44478
/**
* Returns the nearest line for a given point by distance
* @param {Point} point
* @param Array<Point> lines
*
* @return Array<Point>
*/
function getNearestLine(point, lines) {
44487
 var distances = lines.map(function(l) {
   return {
     line: l,
     distance: getDistancePointLine(point, l)
   };
 });
44494
 var sorted = sortBy(distances, 'distance');
44496
 return sorted[0].line;
}
44499
function getResizedSourceAnchor(connection, shape, oldBounds) {
44501
 var waypoints = safeGetWaypoints(connection),
     waypointsInsideNewBounds = getWaypointsInsideBounds(waypoints, shape),
     oldAnchor = waypoints[0];
44505
 // new anchor is the last waypoint enclosed be resized source
 if (waypointsInsideNewBounds.length) {
   return waypointsInsideNewBounds[ waypointsInsideNewBounds.length - 1 ];
 }
44510
 return getNewAttachPoint(oldAnchor.original || oldAnchor, oldBounds, shape);
}
44513
44514
function getResizedTargetAnchor(connection, shape, oldBounds) {
44516
 var waypoints = safeGetWaypoints(connection),
     waypointsInsideNewBounds = getWaypointsInsideBounds(waypoints, shape),
     oldAnchor = waypoints[waypoints.length - 1];
44520
 // new anchor is the first waypoint enclosed be resized target
 if (waypointsInsideNewBounds.length) {
   return waypointsInsideNewBounds[ 0 ];
 }
44525
 return getNewAttachPoint(oldAnchor.original || oldAnchor, oldBounds, shape);
}
44528
44529
function getMovedSourceAnchor(connection, source, moveDelta) {
44531
 var waypoints = safeGetWaypoints(connection),
     oldBounds = subtract(source, moveDelta),
     oldAnchor = waypoints[ 0 ];
44535
 return getNewAttachPoint(oldAnchor.original || oldAnchor, oldBounds, source);
}
44538
44539
function getMovedTargetAnchor(connection, target, moveDelta) {
44541
 var waypoints = safeGetWaypoints(connection),
     oldBounds = subtract(target, moveDelta),
     oldAnchor = waypoints[ waypoints.length - 1 ];
44545
 return getNewAttachPoint(oldAnchor.original || oldAnchor, oldBounds, target);
}
44548
44549
// helpers //////////////////////
44551
function subtract(bounds, delta) {
 return {
   x: bounds.x - delta.x,
   y: bounds.y - delta.y,
   width: bounds.width,
   height: bounds.height
 };
}
44560
44561
/**
* Return waypoints of given connection; throw if non exists (should not happen!!).
*
* @param {Connection} connection
*
* @return {Array<Point>}
*/
function safeGetWaypoints(connection) {
44570
 var waypoints = connection.waypoints;
44572
 if (!waypoints.length) {
   throw new Error('connection#' + connection.id + ': no waypoints');
 }
44576
 return waypoints;
}
44579
function getWaypointsInsideBounds(waypoints, bounds) {
 var originalWaypoints = map(waypoints, getOriginal);
44582
 return filter(originalWaypoints, function(waypoint) {
   return isInsideBounds(waypoint, bounds);
 });
}
44587
/**
* Checks if point is inside bounds, incl. edges.
*
* @param {Point} point
* @param {Bounds} bounds
*/
function isInsideBounds(point, bounds) {
 return getOrientation(bounds, point, 1) === 'intersect';
}
44597
function getOriginal(point) {
 return point.original || point;
}
44601
/**
* BPMN-specific message flow behavior.
*/
function MessageFlowBehavior(eventBus, modeling) {
44606
 CommandInterceptor.call(this, eventBus);
44608
 this.postExecute('shape.replace', function(context) {
   var oldShape = context.oldShape,
       newShape = context.newShape;
44612
   if (!isParticipantCollapse(oldShape, newShape)) {
     return;
   }
44616
   var messageFlows = getMessageFlows(oldShape);
44618
   messageFlows.incoming.forEach(function(incoming) {
     var anchor = getResizedTargetAnchor(incoming, newShape, oldShape);
44621
     modeling.reconnectEnd(incoming, newShape, anchor);
   });
44624
   messageFlows.outgoing.forEach(function(outgoing) {
     var anchor = getResizedSourceAnchor(outgoing, newShape, oldShape);
44627
     modeling.reconnectStart(outgoing, newShape, anchor);
   });
 }, true);
44631
}
44633
MessageFlowBehavior.$inject = [ 'eventBus', 'modeling' ];
44635
inherits$1(MessageFlowBehavior, CommandInterceptor);
44637
// helpers //////////
44639
function isParticipantCollapse(oldShape, newShape) {
 return is$1(oldShape, 'bpmn:Participant')
   && isExpanded(oldShape)
   && is$1(newShape, 'bpmn:Participant')
   && !isExpanded(newShape);
}
44646
function getMessageFlows(parent) {
 var elements = selfAndAllChildren([ parent ], false);
44649
 var incoming = [],
     outgoing = [];
44652
 elements.forEach(function(element) {
   if (element === parent) {
     return;
   }
44657
   element.incoming.forEach(function(connection) {
     if (is$1(connection, 'bpmn:MessageFlow')) {
       incoming.push(connection);
     }
   });
44663
   element.outgoing.forEach(function(connection) {
     if (is$1(connection, 'bpmn:MessageFlow')) {
       outgoing.push(connection);
     }
   });
 }, []);
44670
 return {
   incoming: incoming,
   outgoing: outgoing
 };
}
44676
var COLLAB_ERR_MSG = 'flow elements must be children of pools/participants';
44678
function ModelingFeedback(eventBus, tooltips, translate) {
44680
 function showError(position, message, timeout) {
   tooltips.add({
     position: {
       x: position.x + 5,
       y: position.y + 5
     },
     type: 'error',
     timeout: timeout || 2000,
     html: '<div>' + message + '</div>'
   });
 }
44692
 eventBus.on([ 'shape.move.rejected', 'create.rejected' ], function(event) {
   var context = event.context,
       shape = context.shape,
       target = context.target;
44697
   if (is$1(target, 'bpmn:Collaboration') && is$1(shape, 'bpmn:FlowNode')) {
     showError(event, translate(COLLAB_ERR_MSG));
   }
 });
44702
}
44704
ModelingFeedback.$inject = [
 'eventBus',
 'tooltips',
 'translate'
];
44710
/**
* BPMN specific behavior ensuring that bpmndi:Label's dc:Bounds are removed
* when shape is resized.
*/
function RemoveEmbeddedLabelBoundsBehavior(eventBus, modeling) {
 CommandInterceptor.call(this, eventBus);
44717
 this.preExecute('shape.resize', function(context) {
   var shape = context.shape;
44720
   var di = getDi(shape),
       label = di && di.get('label'),
       bounds = label && label.get('bounds');
44724
   if (bounds) {
     modeling.updateModdleProperties(shape, label, {
       bounds: undefined
     });
   }
 }, true);
}
44732
inherits$1(RemoveEmbeddedLabelBoundsBehavior, CommandInterceptor);
44734
RemoveEmbeddedLabelBoundsBehavior.$inject = [
 'eventBus',
 'modeling'
];
44739
function RemoveElementBehavior(eventBus, bpmnRules, modeling) {
44741
 CommandInterceptor.call(this, eventBus);
44743
 /**
  * Combine sequence flows when deleting an element
  * if there is one incoming and one outgoing
  * sequence flow
  */
 this.preExecute('shape.delete', function(e) {
44750
   var shape = e.context.shape;
44752
   // only handle [a] -> [shape] -> [b] patterns
   if (shape.incoming.length !== 1 || shape.outgoing.length !== 1) {
     return;
   }
44757
   var inConnection = shape.incoming[0],
       outConnection = shape.outgoing[0];
44760
   // only handle sequence flows
   if (!is$1(inConnection, 'bpmn:SequenceFlow') || !is$1(outConnection, 'bpmn:SequenceFlow')) {
     return;
   }
44765
   if (bpmnRules.canConnect(inConnection.source, outConnection.target, inConnection)) {
44767
     // compute new, combined waypoints
     var newWaypoints = getNewWaypoints(inConnection.waypoints, outConnection.waypoints);
44770
     modeling.reconnectEnd(inConnection, outConnection.target, newWaypoints);
   }
 });
44774
}
44776
inherits$1(RemoveElementBehavior, CommandInterceptor);
44778
RemoveElementBehavior.$inject = [
 'eventBus',
 'bpmnRules',
 'modeling'
];
44784
44785
// helpers //////////////////////
44787
function getDocking$1(point) {
 return point.original || point;
}
44791
44792
function getNewWaypoints(inWaypoints, outWaypoints) {
44794
 var intersection = lineIntersect(
   getDocking$1(inWaypoints[inWaypoints.length - 2]),
   getDocking$1(inWaypoints[inWaypoints.length - 1]),
   getDocking$1(outWaypoints[1]),
   getDocking$1(outWaypoints[0]));
44800
 if (intersection) {
   return [].concat(
     inWaypoints.slice(0, inWaypoints.length - 1),
     [ intersection ],
     outWaypoints.slice(1));
 } else {
   return [
     getDocking$1(inWaypoints[0]),
     getDocking$1(outWaypoints[outWaypoints.length - 1])
   ];
 }
}
44813
/**
* BPMN specific remove behavior
*/
function RemoveParticipantBehavior(eventBus, modeling) {
44818
 CommandInterceptor.call(this, eventBus);
44820
44821
 /**
  * morph collaboration diagram into process diagram
  * after the last participant has been removed
  */
44826
 this.preExecute('shape.delete', function(context) {
44828
   var shape = context.shape,
       parent = shape.parent;
44831
   // activate the behavior if the shape to be removed
   // is a participant
   if (is$1(shape, 'bpmn:Participant')) {
     context.collaborationRoot = parent;
   }
 }, true);
44838
 this.postExecute('shape.delete', function(context) {
44840
   var collaborationRoot = context.collaborationRoot;
44842
   if (collaborationRoot && !collaborationRoot.businessObject.participants.length) {
44844
     // replace empty collaboration with process diagram
     modeling.makeProcess();
   }
 }, true);
44849
}
44851
RemoveParticipantBehavior.$inject = [ 'eventBus', 'modeling' ];
44853
inherits$1(RemoveParticipantBehavior, CommandInterceptor);
44855
function ReplaceConnectionBehavior(eventBus, modeling, bpmnRules, injector) {
44857
 CommandInterceptor.call(this, eventBus);
44859
 var dragging = injector.get('dragging', false);
44861
 function fixConnection(connection) {
44863
   var source = connection.source,
       target = connection.target,
       parent = connection.parent;
44867
   // do not do anything if connection
   // is already deleted (may happen due to other
   // behaviors plugged-in before)
   if (!parent) {
     return;
   }
44874
   var replacementType,
       remove;
44877
   /**
    * Check if incoming or outgoing connections
    * can stay or could be substituted with an
    * appropriate replacement.
    *
    * This holds true for SequenceFlow <> MessageFlow.
    */
44885
   if (is$1(connection, 'bpmn:SequenceFlow')) {
     if (!bpmnRules.canConnectSequenceFlow(source, target)) {
       remove = true;
     }
44890
     if (bpmnRules.canConnectMessageFlow(source, target)) {
       replacementType = 'bpmn:MessageFlow';
     }
   }
44895
   // transform message flows into sequence flows, if possible
44897
   if (is$1(connection, 'bpmn:MessageFlow')) {
44899
     if (!bpmnRules.canConnectMessageFlow(source, target)) {
       remove = true;
     }
44903
     if (bpmnRules.canConnectSequenceFlow(source, target)) {
       replacementType = 'bpmn:SequenceFlow';
     }
   }
44908
   if (is$1(connection, 'bpmn:Association') && !bpmnRules.canConnectAssociation(source, target)) {
     remove = true;
   }
44912
44913
   // remove invalid connection,
   // unless it has been removed already
   if (remove) {
     modeling.removeConnection(connection);
   }
44919
   // replace SequenceFlow <> MessageFlow
44921
   if (replacementType) {
     modeling.connect(source, target, {
       type: replacementType,
       waypoints: connection.waypoints.slice()
     });
   }
 }
44929
 function replaceReconnectedConnection(event) {
44931
   var context = event.context,
       connection = context.connection,
       source = context.newSource || connection.source,
       target = context.newTarget || connection.target,
       allowed,
       replacement;
44938
   allowed = bpmnRules.canConnect(source, target);
44940
   if (!allowed || allowed.type === connection.type) {
     return;
   }
44944
   replacement = modeling.connect(source, target, {
     type: allowed.type,
     waypoints: connection.waypoints.slice()
   });
44949
   // remove old connection
   modeling.removeConnection(connection);
44952
   // replace connection in context to reconnect end/start
   context.connection = replacement;
44955
   if (dragging) {
     cleanDraggingSelection(connection, replacement);
   }
 }
44960
 // monkey-patch selection saved in dragging in order to re-select it when operation is finished
 function cleanDraggingSelection(oldConnection, newConnection) {
   var context = dragging.context(),
       previousSelection = context && context.payload.previousSelection,
       index;
44966
   // do nothing if not dragging or no selection was present
   if (!previousSelection || !previousSelection.length) {
     return;
   }
44971
   index = previousSelection.indexOf(oldConnection);
44973
   if (index === -1) {
     return;
   }
44977
   previousSelection.splice(index, 1, newConnection);
 }
44980
 // lifecycle hooks
44982
 this.postExecuted('elements.move', function(context) {
44984
   var closure = context.closure,
       allConnections = closure.allConnections;
44987
   forEach$2(allConnections, fixConnection);
 }, true);
44990
 this.preExecute('connection.reconnect', replaceReconnectedConnection);
44992
 this.postExecuted('element.updateProperties', function(event) {
   var context = event.context,
       properties = context.properties,
       element = context.element,
       businessObject = element.businessObject,
       connection;
44999
   // remove condition on change to default
   if (properties.default) {
     connection = find(
       element.outgoing,
       matchPattern({ id: element.businessObject.default.id })
     );
45006
     if (connection) {
       modeling.updateProperties(connection, { conditionExpression: undefined });
     }
   }
45011
   // remove default from source on change to conditional
   if (properties.conditionExpression && businessObject.sourceRef.default === businessObject) {
     modeling.updateProperties(element.source, { default: undefined });
   }
 });
}
45018
inherits$1(ReplaceConnectionBehavior, CommandInterceptor);
45020
ReplaceConnectionBehavior.$inject = [
 'eventBus',
 'modeling',
 'bpmnRules',
 'injector'
];
45027
/**
* BPMN-specific replace behavior.
*/
function ReplaceElementBehaviour(
   bpmnReplace,
   bpmnRules,
   elementRegistry,
   injector,
   modeling,
   selection
) {
 injector.invoke(CommandInterceptor, this);
45040
 this._bpmnReplace = bpmnReplace;
 this._elementRegistry = elementRegistry;
 this._selection = selection;
45044
 // replace elements on create, e.g. during copy-paste
 this.postExecuted([ 'elements.create' ], 500, function(event) {
   var context = event.context,
       target = context.parent,
       elements = context.elements;
45050
   var canReplace = bpmnRules.canReplace(elements, target);
45052
   if (canReplace) {
     this.replaceElements(elements, canReplace.replacements);
   }
 }, this);
45057
 // replace elements on move
 this.postExecuted([ 'elements.move' ], 500, function(event) {
   var context = event.context,
       target = context.newParent,
       newHost = context.newHost,
       elements = [];
45064
   forEach$2(context.closure.topLevel, function(topLevelElements) {
     if (isEventSubProcess(topLevelElements)) {
       elements = elements.concat(topLevelElements.children);
     } else {
       elements = elements.concat(topLevelElements);
     }
   });
45072
   // set target to host if attaching
   if (elements.length === 1 && newHost) {
     target = newHost;
   }
45077
   var canReplace = bpmnRules.canReplace(elements, target);
45079
   if (canReplace) {
     this.replaceElements(elements, canReplace.replacements, newHost);
   }
 }, this);
45084
 // update attachments on host replace
 this.postExecute([ 'shape.replace' ], 1500, function(e) {
   var context = e.context,
       oldShape = context.oldShape,
       newShape = context.newShape,
       attachers = oldShape.attachers,
       canReplace;
45092
   if (attachers && attachers.length) {
     canReplace = bpmnRules.canReplace(attachers, newShape);
45095
     this.replaceElements(attachers, canReplace.replacements);
   }
45098
 }, this);
45100
 // keep ID on shape replace
 this.postExecuted([ 'shape.replace' ], 1500, function(e) {
   var context = e.context,
       oldShape = context.oldShape,
       newShape = context.newShape;
45106
   modeling.unclaimId(oldShape.businessObject.id, oldShape.businessObject);
   modeling.updateProperties(newShape, { id: oldShape.id });
 });
}
45111
inherits$1(ReplaceElementBehaviour, CommandInterceptor);
45113
ReplaceElementBehaviour.prototype.replaceElements = function(elements, newElements) {
 var elementRegistry = this._elementRegistry,
     bpmnReplace = this._bpmnReplace,
     selection = this._selection;
45118
 forEach$2(newElements, function(replacement) {
   var newElement = {
     type: replacement.newElementType
   };
45123
   var oldElement = elementRegistry.get(replacement.oldElementId);
45125
   var idx = elements.indexOf(oldElement);
45127
   elements[idx] = bpmnReplace.replaceElement(oldElement, newElement, { select: false });
 });
45130
 if (newElements) {
   selection.select(elements);
 }
};
45135
ReplaceElementBehaviour.$inject = [
 'bpmnReplace',
 'bpmnRules',
 'elementRegistry',
 'injector',
 'modeling',
 'selection'
];
45144
var HIGH_PRIORITY$9 = 1500;
45146
var LANE_MIN_DIMENSIONS = { width: 300, height: 60 };
45148
var PARTICIPANT_MIN_DIMENSIONS = { width: 300, height: 150 };
45150
var SUB_PROCESS_MIN_DIMENSIONS = { width: 140, height: 120 };
45152
var TEXT_ANNOTATION_MIN_DIMENSIONS = { width: 50, height: 30 };
45154
/**
* Set minimum bounds/resize constraints on resize.
*
* @param {EventBus} eventBus
*/
function ResizeBehavior(eventBus) {
 eventBus.on('resize.start', HIGH_PRIORITY$9, function(event) {
   var context = event.context,
       shape = context.shape,
       direction = context.direction,
       balanced = context.balanced;
45166
   if (is$1(shape, 'bpmn:Lane') || is$1(shape, 'bpmn:Participant')) {
     context.resizeConstraints = getParticipantResizeConstraints(shape, direction, balanced);
   }
45170
   if (is$1(shape, 'bpmn:Participant')) {
     context.minDimensions = PARTICIPANT_MIN_DIMENSIONS;
   }
45174
   if (is$1(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
     context.minDimensions = SUB_PROCESS_MIN_DIMENSIONS;
   }
45178
   if (is$1(shape, 'bpmn:TextAnnotation')) {
     context.minDimensions = TEXT_ANNOTATION_MIN_DIMENSIONS;
   }
 });
}
45184
ResizeBehavior.$inject = [ 'eventBus' ];
45186
45187
var abs$2 = Math.abs,
   min = Math.min,
   max$2 = Math.max;
45191
45192
function addToTrbl(trbl, attr, value, choice) {
 var current = trbl[attr];
45195
 // make sure to set the value if it does not exist
 // or apply the correct value by comparing against
 // choice(value, currentValue)
 trbl[attr] = current === undefined ? value : choice(value, current);
}
45201
function addMin(trbl, attr, value) {
 return addToTrbl(trbl, attr, value, min);
}
45205
function addMax(trbl, attr, value) {
 return addToTrbl(trbl, attr, value, max$2);
}
45209
var LANE_RIGHT_PADDING = 20,
   LANE_LEFT_PADDING = 50,
   LANE_TOP_PADDING = 20,
   LANE_BOTTOM_PADDING = 20;
45214
function getParticipantResizeConstraints(laneShape, resizeDirection, balanced) {
 var lanesRoot = getLanesRoot(laneShape);
45217
 var isFirst = true,
     isLast = true;
45220
 // max top/bottom size for lanes
 var allLanes = collectLanes(lanesRoot, [ lanesRoot ]);
45223
 var laneTrbl = asTRBL(laneShape);
45225
 var maxTrbl = {},
     minTrbl = {};
45228
 if (/e/.test(resizeDirection)) {
   minTrbl.right = laneTrbl.left + LANE_MIN_DIMENSIONS.width;
 } else
 if (/w/.test(resizeDirection)) {
   minTrbl.left = laneTrbl.right - LANE_MIN_DIMENSIONS.width;
 }
45235
 allLanes.forEach(function(other) {
45237
   var otherTrbl = asTRBL(other);
45239
   if (/n/.test(resizeDirection)) {
45241
     if (otherTrbl.top < (laneTrbl.top - 10)) {
       isFirst = false;
     }
45245
     // max top size (based on next element)
     if (balanced && abs$2(laneTrbl.top - otherTrbl.bottom) < 10) {
       addMax(maxTrbl, 'top', otherTrbl.top + LANE_MIN_DIMENSIONS.height);
     }
45250
     // min top size (based on self or nested element)
     if (abs$2(laneTrbl.top - otherTrbl.top) < 5) {
       addMin(minTrbl, 'top', otherTrbl.bottom - LANE_MIN_DIMENSIONS.height);
     }
   }
45256
   if (/s/.test(resizeDirection)) {
45258
     if (otherTrbl.bottom > (laneTrbl.bottom + 10)) {
       isLast = false;
     }
45262
     // max bottom size (based on previous element)
     if (balanced && abs$2(laneTrbl.bottom - otherTrbl.top) < 10) {
       addMin(maxTrbl, 'bottom', otherTrbl.bottom - LANE_MIN_DIMENSIONS.height);
     }
45267
     // min bottom size (based on self or nested element)
     if (abs$2(laneTrbl.bottom - otherTrbl.bottom) < 5) {
       addMax(minTrbl, 'bottom', otherTrbl.top + LANE_MIN_DIMENSIONS.height);
     }
   }
 });
45274
 // max top/bottom/left/right size based on flow nodes
 var flowElements = lanesRoot.children.filter(function(s) {
   return !s.hidden && !s.waypoints && (is$1(s, 'bpmn:FlowElement') || is$1(s, 'bpmn:Artifact'));
 });
45279
 flowElements.forEach(function(flowElement) {
45281
   var flowElementTrbl = asTRBL(flowElement);
45283
   if (isFirst && /n/.test(resizeDirection)) {
     addMin(minTrbl, 'top', flowElementTrbl.top - LANE_TOP_PADDING);
   }
45287
   if (/e/.test(resizeDirection)) {
     addMax(minTrbl, 'right', flowElementTrbl.right + LANE_RIGHT_PADDING);
   }
45291
   if (isLast && /s/.test(resizeDirection)) {
     addMax(minTrbl, 'bottom', flowElementTrbl.bottom + LANE_BOTTOM_PADDING);
   }
45295
   if (/w/.test(resizeDirection)) {
     addMin(minTrbl, 'left', flowElementTrbl.left - LANE_LEFT_PADDING);
   }
 });
45300
 return {
   min: minTrbl,
   max: maxTrbl
 };
}
45306
var SLIGHTLY_HIGHER_PRIORITY = 1001;
45308
45309
/**
* Invoke {@link Modeling#resizeLane} instead of
* {@link Modeling#resizeShape} when resizing a Lane
* or Participant shape.
*/
function ResizeLaneBehavior(eventBus, modeling) {
45316
 eventBus.on('resize.start', SLIGHTLY_HIGHER_PRIORITY + 500, function(event) {
   var context = event.context,
       shape = context.shape;
45320
   if (is$1(shape, 'bpmn:Lane') || is$1(shape, 'bpmn:Participant')) {
45322
     // should we resize the opposite lane(s) in
     // order to compensate for the resize operation?
     context.balanced = !hasPrimaryModifier(event);
   }
 });
45328
 /**
  * Intercept resize end and call resize lane function instead.
  */
 eventBus.on('resize.end', SLIGHTLY_HIGHER_PRIORITY, function(event) {
   var context = event.context,
       shape = context.shape,
       canExecute = context.canExecute,
       newBounds = context.newBounds;
45337
   if (is$1(shape, 'bpmn:Lane') || is$1(shape, 'bpmn:Participant')) {
45339
     if (canExecute) {
45341
       // ensure we have actual pixel values for new bounds
       // (important when zoom level was > 1 during move)
       newBounds = roundBounds(newBounds);
45345
       // perform the actual resize
       modeling.resizeLane(shape, newBounds, context.balanced);
     }
45349
     // stop propagation
     return false;
   }
 });
}
45355
ResizeLaneBehavior.$inject = [
 'eventBus',
 'modeling'
];
45360
var LOW_PRIORITY$a = 500;
45362
45363
/**
* Add referenced root elements (error, escalation, message, signal) if they don't exist.
* Copy referenced root elements on copy & paste.
*/
function RootElementReferenceBehavior(
   bpmnjs, eventBus, injector, moddleCopy, bpmnFactory
) {
 injector.invoke(CommandInterceptor, this);
45372
 function canHaveRootElementReference(element) {
   return isAny(element, [ 'bpmn:ReceiveTask', 'bpmn:SendTask' ]) ||
     hasAnyEventDefinition(element, [
       'bpmn:ErrorEventDefinition',
       'bpmn:EscalationEventDefinition',
       'bpmn:MessageEventDefinition',
       'bpmn:SignalEventDefinition'
     ]);
 }
45382
 function hasRootElement(rootElement) {
   var definitions = bpmnjs.getDefinitions(),
       rootElements = definitions.get('rootElements');
45386
   return !!find(rootElements, matchPattern({ id: rootElement.id }));
 }
45389
 function getRootElementReferencePropertyName(eventDefinition) {
   if (is$1(eventDefinition, 'bpmn:ErrorEventDefinition')) {
     return 'errorRef';
   } else if (is$1(eventDefinition, 'bpmn:EscalationEventDefinition')) {
     return 'escalationRef';
   } else if (is$1(eventDefinition, 'bpmn:MessageEventDefinition')) {
     return 'messageRef';
   } else if (is$1(eventDefinition, 'bpmn:SignalEventDefinition')) {
     return 'signalRef';
   }
 }
45401
 function getRootElement(businessObject) {
   if (isAny(businessObject, [ 'bpmn:ReceiveTask', 'bpmn:SendTask' ])) {
     return businessObject.get('messageRef');
   }
45406
   var eventDefinitions = businessObject.get('eventDefinitions'),
       eventDefinition = eventDefinitions[ 0 ];
45409
   return eventDefinition.get(getRootElementReferencePropertyName(eventDefinition));
 }
45412
 function setRootElement(businessObject, rootElement) {
   if (isAny(businessObject, [ 'bpmn:ReceiveTask', 'bpmn:SendTask' ])) {
     return businessObject.set('messageRef', rootElement);
   }
45417
   var eventDefinitions = businessObject.get('eventDefinitions'),
       eventDefinition = eventDefinitions[ 0 ];
45420
   return eventDefinition.set(getRootElementReferencePropertyName(eventDefinition), rootElement);
 }
45423
 // create shape
 this.executed('shape.create', function(context) {
   var shape = context.shape;
45427
   if (!canHaveRootElementReference(shape)) {
     return;
   }
45431
   var businessObject = getBusinessObject(shape),
       rootElement = getRootElement(businessObject),
       rootElements;
45435
   if (rootElement && !hasRootElement(rootElement)) {
     rootElements = bpmnjs.getDefinitions().get('rootElements');
45438
     // add root element
     add(rootElements, rootElement);
45441
     context.addedRootElement = rootElement;
   }
 }, true);
45445
 this.reverted('shape.create', function(context) {
   var addedRootElement = context.addedRootElement;
45448
   if (!addedRootElement) {
     return;
   }
45452
   var rootElements = bpmnjs.getDefinitions().get('rootElements');
45454
   // remove root element
   remove(rootElements, addedRootElement);
 }, true);
45458
 eventBus.on('copyPaste.copyElement', function(context) {
   var descriptor = context.descriptor,
       element = context.element;
45462
   if (!canHaveRootElementReference(element)) {
     return;
   }
45466
   var businessObject = getBusinessObject(element),
       rootElement = getRootElement(businessObject);
45469
   if (rootElement) {
     descriptor.referencedRootElement = rootElement;
   }
 });
45474
 eventBus.on('copyPaste.pasteElement', LOW_PRIORITY$a, function(context) {
   var descriptor = context.descriptor,
       businessObject = descriptor.businessObject;
45478
   if (!canHaveRootElementReference(businessObject)) {
     return;
   }
45482
   var referencedRootElement = descriptor.referencedRootElement;
45484
   if (!referencedRootElement) {
     return;
   }
45488
   if (!hasRootElement(referencedRootElement)) {
     referencedRootElement = moddleCopy.copyElement(
       referencedRootElement,
       bpmnFactory.create(referencedRootElement.$type)
     );
   }
45495
   setRootElement(businessObject, referencedRootElement);
 });
}
45499
RootElementReferenceBehavior.$inject = [
 'bpmnjs',
 'eventBus',
 'injector',
 'moddleCopy',
 'bpmnFactory'
];
45507
inherits$1(RootElementReferenceBehavior, CommandInterceptor);
45509
// helpers //////////
45511
function hasAnyEventDefinition(element, types) {
 if (!isArray$4(types)) {
   types = [ types ];
 }
45516
 return some(types, function(type) {
   return hasEventDefinition$2(element, type);
 });
}
45521
var max$1 = Math.max;
45523
45524
function SpaceToolBehavior(eventBus) {
 eventBus.on('spaceTool.getMinDimensions', function(context) {
   var shapes = context.shapes,
       axis = context.axis,
       start = context.start,
       minDimensions = {};
45531
   forEach$2(shapes, function(shape) {
     var id = shape.id;
45534
     if (is$1(shape, 'bpmn:Participant')) {
45536
       if (isHorizontal$1(axis)) {
         minDimensions[ id ] = PARTICIPANT_MIN_DIMENSIONS;
       } else {
         minDimensions[ id ] = {
           width: PARTICIPANT_MIN_DIMENSIONS.width,
           height: getParticipantMinHeight(shape, start)
         };
       }
45545
     }
45547
     if (is$1(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
       minDimensions[ id ] = SUB_PROCESS_MIN_DIMENSIONS;
     }
45551
     if (is$1(shape, 'bpmn:TextAnnotation')) {
       minDimensions[ id ] = TEXT_ANNOTATION_MIN_DIMENSIONS;
     }
   });
45556
   return minDimensions;
 });
}
45560
SpaceToolBehavior.$inject = [ 'eventBus' ];
45562
45563
// helpers //////////
function isHorizontal$1(axis) {
 return axis === 'x';
}
45568
/**
* Get minimum height for participant taking lanes into account.
*
* @param {<djs.model.Shape>} participant
* @param {number} start
*
* @returns {Object}
*/
function getParticipantMinHeight(participant, start) {
 var lanesMinHeight;
45579
 if (!hasChildLanes(participant)) {
   return PARTICIPANT_MIN_DIMENSIONS.height;
 }
45583
 lanesMinHeight = getLanesMinHeight(participant, start);
45585
 return max$1(PARTICIPANT_MIN_DIMENSIONS.height, lanesMinHeight);
}
45588
function hasChildLanes(element) {
 return !!getChildLanes(element).length;
}
45592
function getLanesMinHeight(participant, resizeStart) {
 var lanes = getChildLanes(participant),
     resizedLane;
45596
 // find the nested lane which is currently resized
 resizedLane = findResizedLane(lanes, resizeStart);
45599
 // resized lane cannot shrink below the minimum height
 // but remaining lanes' dimensions are kept intact
 return participant.height - resizedLane.height + LANE_MIN_DIMENSIONS.height;
}
45604
/**
* Find nested lane which is currently resized.
*
* @param {Array<djs.model.Shape>} lanes
* @param {number} resizeStart
*/
function findResizedLane(lanes, resizeStart) {
 var i, lane, childLanes;
45613
 for (i = 0; i < lanes.length; i++) {
   lane = lanes[i];
45616
   // resizing current lane or a lane nested
   if (resizeStart >= lane.y && resizeStart <= lane.y + lane.height) {
     childLanes = getChildLanes(lane);
45620
     // a nested lane is resized
     if (childLanes.length) {
       return findResizedLane(childLanes, resizeStart);
     }
45625
     // current lane is the resized one
     return lane;
   }
 }
}
45631
var LOW_PRIORITY$9 = 400;
var HIGH_PRIORITY$8 = 600;
45634
var DEFAULT_POSITION = {
 x: 180,
 y: 160
};
45639
45640
/**
* Creates bpmndi:BPMNPlane elements and canvas planes when collapsed subprocesses are created.
*
*
* @param {Canvas} canvas
* @param {EventBus} eventBus
* @param {Modeling} modeling
* @param {ElementFactory} elementFactory
* @param {BpmnFactory} bpmnFactory
* @param {Bpmnjs} bpmnjs
* @param {ElementRegistry} elementRegistry
*/
function SubProcessPlaneBehavior(
   canvas, eventBus, modeling,
   elementFactory, bpmnFactory, bpmnjs, elementRegistry) {
45656
 CommandInterceptor.call(this, eventBus);
45658
 this._canvas = canvas;
 this._eventBus = eventBus;
 this._modeling = modeling;
 this._elementFactory = elementFactory;
 this._bpmnFactory = bpmnFactory;
 this._bpmnjs = bpmnjs;
 this._elementRegistry = elementRegistry;
45666
 var self = this;
45668
 function isCollapsedSubProcess(element) {
   return is$1(element, 'bpmn:SubProcess') && !isExpanded(element);
 }
45672
 function createRoot(context) {
   var shape = context.shape,
       rootElement = context.newRootElement;
45676
   var businessObject = getBusinessObject(shape);
45678
   rootElement = self._addDiagram(rootElement || businessObject);
45680
   context.newRootElement = canvas.addRootElement(rootElement);
 }
45683
 function removeRoot(context) {
   var shape = context.shape;
45686
   var businessObject = getBusinessObject(shape);
   self._removeDiagram(businessObject);
45689
   var rootElement = context.newRootElement = elementRegistry.get(getPlaneIdFromShape(businessObject));
45691
   canvas.removeRootElement(rootElement);
 }
45694
 // add plane elements for newly created sub-processes
 // this ensures we can actually drill down into the element
 this.executed('shape.create', function(context) {
   var shape = context.shape;
   if (!isCollapsedSubProcess(shape)) {
     return;
   }
45702
   createRoot(context);
 }, true);
45705
45706
 this.postExecuted('shape.create', function(context) {
   var shape = context.shape,
       rootElement = context.newRootElement;
45710
   if (!rootElement || !shape.children) {
     return;
   }
45714
   self._showRecursively(shape.children);
45716
   self._moveChildrenToShape(shape, rootElement);
 }, true);
45719
45720
 this.reverted('shape.create', function(context) {
   var shape = context.shape;
   if (!isCollapsedSubProcess(shape)) {
     return;
   }
45726
   removeRoot(context);
 }, true);
45729
45730
 this.preExecuted('shape.delete', function(context) {
   var shape = context.shape;
   if (!isCollapsedSubProcess(shape)) {
     return;
   }
45736
   var attachedRoot = elementRegistry.get(getPlaneIdFromShape(shape));
45738
   if (!attachedRoot) {
     return;
   }
45742
   modeling.removeElements(attachedRoot.children.slice());
 }, true);
45745
45746
 this.executed('shape.delete', function(context) {
   var shape = context.shape;
   if (!isCollapsedSubProcess(shape)) {
     return;
   }
   removeRoot(context);
 }, true);
45754
45755
 this.reverted('shape.delete', function(context) {
   var shape = context.shape;
   if (!isCollapsedSubProcess(shape)) {
     return;
   }
45761
   createRoot(context);
 }, true);
45764
45765
 this.preExecuted('shape.replace', function(context) {
   var oldShape = context.oldShape;
   var newShape = context.newShape;
45769
   if (!isCollapsedSubProcess(oldShape) || !isCollapsedSubProcess(newShape)) {
     return;
   }
45773
   // old plane could have content,
   // we remove it so it is not recursively deleted from 'shape.delete'
   context.oldRoot = canvas.removeRootElement(getPlaneIdFromShape(oldShape));
 }, true);
45778
45779
 this.postExecuted('shape.replace', function(context) {
   var newShape = context.newShape,
       source = context.oldRoot,
       target = canvas.findRoot(getPlaneIdFromShape(newShape));
45784
   if (!source || !target) {
     return;
   }
   var elements = source.children;
45789
   modeling.moveElements(elements, { x: 0, y: 0 }, target);
 }, true);
45792
45793
 // rename primary elements when the secondary element changes
 // this ensures rootElement.id = element.id + '_plane'
 this.executed('element.updateProperties', function(context) {
   var shape = context.element;
45798
   if (!is$1(shape, 'bpmn:SubProcess')) {
     return;
   }
45802
   var properties = context.properties;
   var oldProperties = context.oldProperties;
45805
   var oldId = oldProperties.id,
       newId = properties.id;
45808
   if (oldId === newId) {
     return;
   }
45812
   if (isPlane(shape)) {
     elementRegistry.updateId(shape, toPlaneId(newId));
     elementRegistry.updateId(oldId, newId);
45816
     return;
   }
45819
   var planeElement = elementRegistry.get(toPlaneId(oldId));
45821
   if (!planeElement) {
     return;
   }
45825
   elementRegistry.updateId(toPlaneId(oldId), toPlaneId(newId));
 }, true);
45828
45829
 this.reverted('element.updateProperties', function(context) {
   var shape = context.element;
45832
   if (!is$1(shape, 'bpmn:SubProcess')) {
     return;
   }
45836
   var properties = context.properties;
   var oldProperties = context.oldProperties;
45839
   var oldId = oldProperties.id,
       newId = properties.id;
45842
   if (oldId === newId) {
     return;
   }
45846
   if (isPlane(shape)) {
     elementRegistry.updateId(shape, toPlaneId(oldId));
     elementRegistry.updateId(newId, oldId);
45850
     return;
   }
45853
   var planeElement = elementRegistry.get(toPlaneId(newId));
45855
   if (!planeElement) {
     return;
   }
45859
   elementRegistry.updateId(planeElement, toPlaneId(oldId));
 }, true);
45862
 // re-throw element.changed to re-render primary shape if associated plane has
 // changed (e.g. bpmn:name property has changed)
 eventBus.on('element.changed', function(context) {
   var element = context.element;
45867
   if (!isPlane(element)) {
     return;
   }
45871
   var plane = element;
45873
   var primaryShape = elementRegistry.get(getShapeIdFromPlane(plane));
45875
   // do not re-throw if no associated primary shape (e.g. bpmn:Process)
   if (!primaryShape || primaryShape === plane) {
     return;
   }
45880
   eventBus.fire('element.changed', { element: primaryShape });
 });
45883
45884
 // create/remove plane for the subprocess
 this.executed('shape.toggleCollapse', LOW_PRIORITY$9, function(context) {
   var shape = context.shape;
45888
   if (!is$1(shape, 'bpmn:SubProcess')) {
     return;
   }
45892
   if (!isExpanded(shape)) {
     createRoot(context);
     self._showRecursively(shape.children);
   } else {
     removeRoot(context);
   }
45899
 }, true);
45901
45902
 // create/remove plane for the subprocess
 this.reverted('shape.toggleCollapse', LOW_PRIORITY$9, function(context) {
   var shape = context.shape;
45906
   if (!is$1(shape, 'bpmn:SubProcess')) {
     return;
   }
45910
   if (!isExpanded(shape)) {
     createRoot(context);
     self._showRecursively(shape.children);
   } else {
     removeRoot(context);
   }
45917
 }, true);
45919
 // move elements between planes
 this.postExecuted('shape.toggleCollapse', HIGH_PRIORITY$8, function(context) {
   var shape = context.shape;
45923
   if (!is$1(shape, 'bpmn:SubProcess')) {
     return;
   }
45927
   var rootElement = context.newRootElement;
45929
   if (!rootElement) {
     return;
   }
45933
   if (!isExpanded(shape)) {
45935
     // collapsed
     self._moveChildrenToShape(shape, rootElement);
45938
   } else {
     self._moveChildrenToShape(rootElement, shape);
   }
 }, true);
45943
45944
 // copy-paste ///////////
45946
 // add elements in plane to tree
 eventBus.on('copyPaste.createTree', function(context) {
   var element = context.element,
       children = context.children;
45951
   if (!isCollapsedSubProcess(element)) {
     return;
   }
45955
   var id = getPlaneIdFromShape(element);
   var parent = elementRegistry.get(id);
45958
   if (parent) {
45960
     // do not copy invisible root element
     children.push.apply(children, parent.children);
   }
 });
45965
 // set plane children as direct children of collapsed shape
 eventBus.on('copyPaste.copyElement', function(context) {
   var descriptor = context.descriptor,
       element = context.element,
       elements = context.elements;
45971
   var parent = element.parent;
45973
   var isPlane = is$1(getDi(parent), 'bpmndi:BPMNPlane');
   if (!isPlane) {
     return;
   }
45978
   var parentId = getShapeIdFromPlane(parent);
45980
   var referencedShape = find(elements, function(element) {
     return element.id === parentId;
   });
45984
   if (!referencedShape) {
     return;
   }
45988
   descriptor.parent = referencedShape.id;
 });
45991
 // hide children during pasting
 eventBus.on('copyPaste.pasteElement', function(context) {
   var descriptor = context.descriptor;
45995
   if (!descriptor.parent) {
     return;
   }
45999
   if (isCollapsedSubProcess(descriptor.parent) || descriptor.parent.hidden) {
     descriptor.hidden = true;
   }
 });
46004
}
46006
inherits$1(SubProcessPlaneBehavior, CommandInterceptor);
46008
/**
* Moves the child elements from source to target.
*
* If the target is a plane, the children are moved to the top left corner.
* Otherwise, the center of the target is used.
*
* @param {Object|djs.model.Base} source
* @param {Object|djs.model.Base} target
*/
SubProcessPlaneBehavior.prototype._moveChildrenToShape = function(source, target) {
 var modeling = this._modeling;
46020
 var children = source.children;
 var offset;
46023
 if (!children) {
   return;
 }
46027
 // only change plane if there are no visible children, but don't move them
 var visibleChildren = children.filter(function(child) {
   return !child.hidden;
 });
46032
 if (!visibleChildren.length) {
   modeling.moveElements(children, { x: 0, y: 0 }, target, { autoResize: false });
   return;
 }
46037
 var childrenBounds = getBBox(visibleChildren);
46039
 // target is a plane
 if (!target.x) {
   offset = {
     x: DEFAULT_POSITION.x - childrenBounds.x,
     y: DEFAULT_POSITION.y - childrenBounds.y
   };
 }
46047
 // source is a plane
 else {
46050
   // move relative to the center of the shape
   var targetMid = getMid(target);
   var childrenMid = getMid(childrenBounds);
46054
   offset = {
     x: targetMid.x - childrenMid.x,
     y: targetMid.y - childrenMid.y
   };
 }
46060
 modeling.moveElements(children, offset, target, { autoResize: false });
};
46063
/**
* Sets `hidden` property on all children of the given shape.
*
* @param {Array} elements
* @param {Boolean} [hidden]
* @returns {Array} all child elements
*/
SubProcessPlaneBehavior.prototype._showRecursively = function(elements, hidden) {
 var self = this;
46073
 var result = [];
 elements.forEach(function(element) {
   element.hidden = !!hidden;
46077
   result = result.concat(element);
46079
   if (element.children) {
     result = result.concat(
       self._showRecursively(element.children, element.collapsed || hidden)
     );
   }
 });
46086
 return result;
};
46089
/**
* Adds a given rootElement to the bpmnDi diagrams.
*
* @param {Object} rootElement
* @returns {Object} planeElement
*/
SubProcessPlaneBehavior.prototype._addDiagram = function(planeElement) {
 var bpmnjs = this._bpmnjs;
 var diagrams = bpmnjs.getDefinitions().diagrams;
46099
 if (!planeElement.businessObject) {
   planeElement = this._createNewDiagram(planeElement);
 }
46103
 diagrams.push(planeElement.di.$parent);
46105
 return planeElement;
};
46108
46109
/**
* Creates a new plane element for the given sub process.
*
* @param {Object} bpmnElement
*
* @return {Object} new diagram element
*/
SubProcessPlaneBehavior.prototype._createNewDiagram = function(bpmnElement) {
 var bpmnFactory = this._bpmnFactory;
 var elementFactory = this._elementFactory;
46120
 var diPlane = bpmnFactory.create('bpmndi:BPMNPlane', {
   bpmnElement: bpmnElement
 });
 var diDiagram = bpmnFactory.create('bpmndi:BPMNDiagram', {
   plane: diPlane
 });
 diPlane.$parent = diDiagram;
46128
 // add a virtual element (not being drawn),
 // a copy cat of our BpmnImporter code
 var planeElement = elementFactory.createRoot({
   id: getPlaneIdFromShape(bpmnElement),
   type: bpmnElement.$type,
   di: diPlane,
   businessObject: bpmnElement,
   collapsed: true
 });
46138
 return planeElement;
};
46141
/**
* Removes the diagram for a given root element
*
* @param {Object} rootElement
* @returns {Object} removed bpmndi:BPMNDiagram
*/
SubProcessPlaneBehavior.prototype._removeDiagram = function(rootElement) {
 var bpmnjs = this._bpmnjs;
46150
 var diagrams = bpmnjs.getDefinitions().diagrams;
46152
 var removedDiagram = find(diagrams, function(diagram) {
   return diagram.plane.bpmnElement.id === rootElement.id;
 });
46156
 diagrams.splice(diagrams.indexOf(removedDiagram), 1);
46158
 return removedDiagram;
};
46161
46162
SubProcessPlaneBehavior.$inject = [
 'canvas',
 'eventBus',
 'modeling',
 'elementFactory',
 'bpmnFactory',
 'bpmnjs',
 'elementRegistry'
];
46172
/**
* Add start event replacing element with expanded sub process.
*
* @param {Injector} injector
* @param {Modeling} modeling
*/
function SubProcessStartEventBehavior(injector, modeling) {
 injector.invoke(CommandInterceptor, this);
46181
 this.postExecuted('shape.replace', function(event) {
   var oldShape = event.context.oldShape,
       newShape = event.context.newShape;
46185
   if (
     !is$1(newShape, 'bpmn:SubProcess') ||
     ! (is$1(oldShape, 'bpmn:Task') || is$1(oldShape, 'bpmn:CallActivity')) ||
     !isExpanded(newShape)
   ) {
     return;
   }
46193
   var position = getStartEventPosition(newShape);
46195
   modeling.createShape({ type: 'bpmn:StartEvent' }, position, newShape);
 });
}
46199
SubProcessStartEventBehavior.$inject = [
 'injector',
 'modeling'
];
46204
inherits$1(SubProcessStartEventBehavior, CommandInterceptor);
46206
// helpers //////////
46208
function getStartEventPosition(shape) {
 return {
   x: shape.x + shape.width / 6,
   y: shape.y + shape.height / 2
 };
}
46215
function ToggleCollapseConnectionBehaviour(
   eventBus, modeling
) {
46219
 CommandInterceptor.call(this, eventBus);
46221
 this.postExecuted('shape.toggleCollapse', 1500, function(context) {
46223
   // var shape = context.shape;
   var shape = context.shape;
46226
   // only change connections when collapsing
   if (isExpanded(shape)) {
     return;
   }
46231
   var allChildren = selfAndAllChildren(shape);
46233
   allChildren.forEach(function(child) {
46235
     // Ensure that the connection array is not modified during iteration
     var incomingConnections = child.incoming.slice(),
         outgoingConnections = child.outgoing.slice();
46239
     forEach$2(incomingConnections, function(c) {
       handleConnection(c, true);
     });
46243
     forEach$2(outgoingConnections, function(c) {
       handleConnection(c, false);
     });
   });
46248
46249
   function handleConnection(c, incoming) {
     if (allChildren.indexOf(c.source) !== -1 && allChildren.indexOf(c.target) !== -1) {
       return;
     }
46254
     if (incoming) {
       modeling.reconnectEnd(c, shape, getMid(shape));
     } else {
       modeling.reconnectStart(c, shape, getMid(shape));
     }
46260
   }
46262
 }, true);
46264
}
46266
inherits$1(ToggleCollapseConnectionBehaviour, CommandInterceptor);
46268
ToggleCollapseConnectionBehaviour.$inject = [
 'eventBus',
 'modeling',
];
46273
var LOW_PRIORITY$8 = 500;
46275
46276
function ToggleElementCollapseBehaviour(
   eventBus, elementFactory, modeling,
   resize) {
46280
 CommandInterceptor.call(this, eventBus);
46282
46283
 function hideEmptyLabels(children) {
   if (children.length) {
     children.forEach(function(child) {
       if (child.type === 'label' && !child.businessObject.name) {
         child.hidden = true;
       }
     });
   }
 }
46293
 function expandedBounds(shape, defaultSize) {
   var children = shape.children,
       newBounds = defaultSize,
       visibleElements,
       visibleBBox;
46299
   visibleElements = filterVisible(children).concat([ shape ]);
46301
   visibleBBox = computeChildrenBBox(visibleElements);
46303
   if (visibleBBox) {
46305
     // center to visibleBBox with max(defaultSize, childrenBounds)
     newBounds.width = Math.max(visibleBBox.width, newBounds.width);
     newBounds.height = Math.max(visibleBBox.height, newBounds.height);
46309
     newBounds.x = visibleBBox.x + (visibleBBox.width - newBounds.width) / 2;
     newBounds.y = visibleBBox.y + (visibleBBox.height - newBounds.height) / 2;
   } else {
46313
     // center to collapsed shape with defaultSize
     newBounds.x = shape.x + (shape.width - newBounds.width) / 2;
     newBounds.y = shape.y + (shape.height - newBounds.height) / 2;
   }
46318
   return newBounds;
 }
46321
 function collapsedBounds(shape, defaultSize) {
46323
   return {
     x: shape.x + (shape.width - defaultSize.width) / 2,
     y: shape.y + (shape.height - defaultSize.height) / 2,
     width: defaultSize.width,
     height: defaultSize.height
   };
 }
46331
 this.executed([ 'shape.toggleCollapse' ], LOW_PRIORITY$8, function(e) {
46333
   var context = e.context,
       shape = context.shape;
46336
   if (!is$1(shape, 'bpmn:SubProcess')) {
     return;
   }
46340
   if (!shape.collapsed) {
46342
     // all children got made visible through djs, hide empty labels
     hideEmptyLabels(shape.children);
46345
     // remove collapsed marker
     getDi(shape).isExpanded = true;
   } else {
46349
     // place collapsed marker
     getDi(shape).isExpanded = false;
   }
 });
46354
 this.reverted([ 'shape.toggleCollapse' ], LOW_PRIORITY$8, function(e) {
46356
   var context = e.context;
   var shape = context.shape;
46359
46360
   // revert removing/placing collapsed marker
   if (!shape.collapsed) {
     getDi(shape).isExpanded = true;
46364
   } else {
     getDi(shape).isExpanded = false;
   }
 });
46369
 this.postExecuted([ 'shape.toggleCollapse' ], LOW_PRIORITY$8, function(e) {
   var shape = e.context.shape,
       defaultSize = elementFactory.getDefaultSize(shape),
       newBounds;
46374
   if (shape.collapsed) {
46376
     // resize to default size of collapsed shapes
     newBounds = collapsedBounds(shape, defaultSize);
   } else {
46380
     // resize to bounds of max(visible children, defaultSize)
     newBounds = expandedBounds(shape, defaultSize);
   }
46384
   modeling.resizeShape(shape, newBounds, null, {
     autoResize: shape.collapsed ? false : 'nwse'
   });
 });
46389
}
46391
46392
inherits$1(ToggleElementCollapseBehaviour, CommandInterceptor);
46394
ToggleElementCollapseBehaviour.$inject = [
 'eventBus',
 'elementFactory',
 'modeling'
];
46400
46401
// helpers //////////////////////
46403
function filterVisible(elements) {
 return elements.filter(function(e) {
   return !e.hidden;
 });
}
46409
/**
* Unclaims model IDs on element deletion.
*
* @param {Canvas} canvas
* @param {Injector} injector
* @param {Moddle} moddle
* @param {Modeling} modeling
*/
function UnclaimIdBehavior(canvas, injector, moddle, modeling) {
 injector.invoke(CommandInterceptor, this);
46420
 this.preExecute('shape.delete', function(event) {
   var context = event.context,
       shape = context.shape,
       shapeBo = shape.businessObject;
46425
   if (isLabel$6(shape)) {
     return;
   }
46429
   if (is$1(shape, 'bpmn:Participant') && isExpanded(shape)) {
     moddle.ids.unclaim(shapeBo.processRef.id);
   }
46433
   modeling.unclaimId(shapeBo.id, shapeBo);
 });
46436
46437
 this.preExecute('connection.delete', function(event) {
   var context = event.context,
       connection = context.connection,
       connectionBo = connection.businessObject;
46442
   modeling.unclaimId(connectionBo.id, connectionBo);
 });
46445
 this.preExecute('canvas.updateRoot', function() {
   var rootElement = canvas.getRootElement(),
       rootElementBo = rootElement.businessObject;
46449
   if (is$1(rootElement, 'bpmn:Collaboration')) {
     moddle.ids.unclaim(rootElementBo.id);
   }
 });
}
46455
inherits$1(UnclaimIdBehavior, CommandInterceptor);
46457
UnclaimIdBehavior.$inject = [ 'canvas', 'injector', 'moddle', 'modeling' ];
46459
/**
* A behavior that unsets the Default property of
* sequence flow source on element delete, if the
* removed element is the Gateway or Task's default flow.
*
* @param {EventBus} eventBus
* @param {Modeling} modeling
*/
function DeleteSequenceFlowBehavior(eventBus, modeling) {
46469
 CommandInterceptor.call(this, eventBus);
46471
46472
 this.preExecute('connection.delete', function(event) {
   var context = event.context,
       connection = context.connection,
       source = connection.source;
46477
   if (isDefaultFlow(connection, source)) {
     modeling.updateProperties(source, {
       'default': null
     });
   }
 });
}
46485
inherits$1(DeleteSequenceFlowBehavior, CommandInterceptor);
46487
DeleteSequenceFlowBehavior.$inject = [
 'eventBus',
 'modeling'
];
46492
46493
// helpers //////////////////////
46495
function isDefaultFlow(connection, source) {
46497
 if (!is$1(connection, 'bpmn:SequenceFlow')) {
   return false;
 }
46501
 var sourceBo = getBusinessObject(source),
     sequenceFlow = getBusinessObject(connection);
46504
 return sourceBo.get('default') === sequenceFlow;
}
46507
var LOW_PRIORITY$7 = 500,
   HIGH_PRIORITY$7 = 5000;
46510
46511
/**
* BPMN specific delete lane behavior
*/
function UpdateFlowNodeRefsBehavior(eventBus, modeling, translate) {
46516
 CommandInterceptor.call(this, eventBus);
46518
 /**
  * Ok, this is it:
  *
  * We have to update the Lane#flowNodeRefs _and_
  * FlowNode#lanes with every FlowNode move/resize and
  * Lane move/resize.
  *
  * We want to group that stuff to recompute containments
  * as efficient as possible.
  *
  * Yea!
  */
46531
 // the update context
 var context;
46534
46535
 function initContext() {
   context = context || new UpdateContext();
   context.enter();
46539
   return context;
 }
46542
 function getContext() {
   if (!context) {
     throw new Error(translate('out of bounds release'));
   }
46547
   return context;
 }
46550
 function releaseContext() {
46552
   if (!context) {
     throw new Error(translate('out of bounds release'));
   }
46556
   var triggerUpdate = context.leave();
46558
   if (triggerUpdate) {
     modeling.updateLaneRefs(context.flowNodes, context.lanes);
46561
     context = null;
   }
46564
   return triggerUpdate;
 }
46567
46568
 var laneRefUpdateEvents = [
   'spaceTool',
   'lane.add',
   'lane.resize',
   'lane.split',
   'elements.create',
   'elements.delete',
   'elements.move',
   'shape.create',
   'shape.delete',
   'shape.move',
   'shape.resize'
 ];
46582
46583
 // listen to a lot of stuff to group lane updates
46585
 this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY$7, function(event) {
   initContext();
 });
46589
 this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY$7, function(event) {
   releaseContext();
 });
46593
46594
 // Mark flow nodes + lanes that need an update
46596
 this.preExecute([
   'shape.create',
   'shape.move',
   'shape.delete',
   'shape.resize'
 ], function(event) {
46603
   var context = event.context,
       shape = context.shape;
46606
   var updateContext = getContext();
46608
   // no need to update labels
   if (shape.labelTarget) {
     return;
   }
46613
   if (is$1(shape, 'bpmn:Lane')) {
     updateContext.addLane(shape);
   }
46617
   if (is$1(shape, 'bpmn:FlowNode')) {
     updateContext.addFlowNode(shape);
   }
 });
}
46623
UpdateFlowNodeRefsBehavior.$inject = [
 'eventBus',
 'modeling' ,
 'translate'
];
46629
inherits$1(UpdateFlowNodeRefsBehavior, CommandInterceptor);
46631
46632
function UpdateContext() {
46634
 this.flowNodes = [];
 this.lanes = [];
46637
 this.counter = 0;
46639
 this.addLane = function(lane) {
   this.lanes.push(lane);
 };
46643
 this.addFlowNode = function(flowNode) {
   this.flowNodes.push(flowNode);
 };
46647
 this.enter = function() {
   this.counter++;
 };
46651
 this.leave = function() {
   this.counter--;
46654
   return !this.counter;
 };
}
46658
var BehaviorModule = {
 __init__: [
   'adaptiveLabelPositioningBehavior',
   'appendBehavior',
   'associationBehavior',
   'attachEventBehavior',
   'boundaryEventBehavior',
   'createBehavior',
   'createDataObjectBehavior',
   'createParticipantBehavior',
   'dataInputAssociationBehavior',
   'dataStoreBehavior',
   'deleteLaneBehavior',
   'detachEventBehavior',
   'dropOnFlowBehavior',
   'eventBasedGatewayBehavior',
   'fixHoverBehavior',
   'groupBehavior',
   'importDockingFix',
   'isHorizontalFix',
   'labelBehavior',
   'messageFlowBehavior',
   'modelingFeedback',
   'removeElementBehavior',
   'removeEmbeddedLabelBoundsBehavior',
   'removeParticipantBehavior',
   'replaceConnectionBehavior',
   'replaceElementBehaviour',
   'resizeBehavior',
   'resizeLaneBehavior',
   'rootElementReferenceBehavior',
   'spaceToolBehavior',
   'subProcessPlaneBehavior',
   'subProcessStartEventBehavior',
   'toggleCollapseConnectionBehaviour',
   'toggleElementCollapseBehaviour',
   'unclaimIdBehavior',
   'updateFlowNodeRefsBehavior',
   'unsetDefaultFlowBehavior'
 ],
 adaptiveLabelPositioningBehavior: [ 'type', AdaptiveLabelPositioningBehavior ],
 appendBehavior: [ 'type', AppendBehavior ],
 associationBehavior: [ 'type', AssociationBehavior ],
 attachEventBehavior: [ 'type', AttachEventBehavior ],
 boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
 createBehavior: [ 'type', CreateBehavior ],
 createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
 createParticipantBehavior: [ 'type', CreateParticipantBehavior ],
 dataInputAssociationBehavior: [ 'type', DataInputAssociationBehavior ],
 dataStoreBehavior: [ 'type', DataStoreBehavior ],
 deleteLaneBehavior: [ 'type', DeleteLaneBehavior ],
 detachEventBehavior: [ 'type', DetachEventBehavior ],
 dropOnFlowBehavior: [ 'type', DropOnFlowBehavior ],
 eventBasedGatewayBehavior: [ 'type', EventBasedGatewayBehavior ],
 fixHoverBehavior: [ 'type', FixHoverBehavior ],
 groupBehavior: [ 'type', GroupBehavior ],
 importDockingFix: [ 'type', ImportDockingFix ],
 isHorizontalFix: [ 'type', IsHorizontalFix ],
 labelBehavior: [ 'type', LabelBehavior ],
 messageFlowBehavior: [ 'type', MessageFlowBehavior ],
 modelingFeedback: [ 'type', ModelingFeedback ],
 removeElementBehavior: [ 'type', RemoveElementBehavior ],
 removeEmbeddedLabelBoundsBehavior: ['type', RemoveEmbeddedLabelBoundsBehavior ],
 removeParticipantBehavior: [ 'type', RemoveParticipantBehavior ],
 replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],
 replaceElementBehaviour: [ 'type', ReplaceElementBehaviour ],
 resizeBehavior: [ 'type', ResizeBehavior ],
 resizeLaneBehavior: [ 'type', ResizeLaneBehavior ],
 rootElementReferenceBehavior: [ 'type', RootElementReferenceBehavior ],
 spaceToolBehavior: [ 'type', SpaceToolBehavior ],
 subProcessPlaneBehavior: [ 'type', SubProcessPlaneBehavior ],
 subProcessStartEventBehavior: [ 'type', SubProcessStartEventBehavior ],
 toggleCollapseConnectionBehaviour: [ 'type', ToggleCollapseConnectionBehaviour ],
 toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
 unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],
 unsetDefaultFlowBehavior: [ 'type', DeleteSequenceFlowBehavior ],
 updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ]
};
46737
function getBoundaryAttachment(position, targetBounds) {
46739
 var orientation = getOrientation(position, targetBounds, -15);
46741
 if (orientation !== 'intersect') {
   return orientation;
 } else {
   return null;
 }
}
46748
/**
* BPMN specific modeling rule
*/
function BpmnRules(eventBus) {
 RuleProvider.call(this, eventBus);
}
46755
inherits$1(BpmnRules, RuleProvider);
46757
BpmnRules.$inject = [ 'eventBus' ];
46759
BpmnRules.prototype.init = function() {
46761
 this.addRule('connection.start', function(context) {
   var source = context.source;
46764
   return canStartConnection(source);
 });
46767
 this.addRule('connection.create', function(context) {
   var source = context.source,
       target = context.target,
       hints = context.hints || {},
       targetParent = hints.targetParent,
       targetAttach = hints.targetAttach;
46774
   // don't allow incoming connections on
   // newly created boundary events
   // to boundary events
   if (targetAttach) {
     return false;
   }
46781
   // temporarily set target parent for scoping
   // checks to work
   if (targetParent) {
     target.parent = targetParent;
   }
46787
   try {
     return canConnect(source, target);
   } finally {
46791
     // unset temporary target parent
     if (targetParent) {
       target.parent = null;
     }
   }
 });
46798
 this.addRule('connection.reconnect', function(context) {
46800
   var connection = context.connection,
       source = context.source,
       target = context.target;
46804
   return canConnect(source, target, connection);
 });
46807
 this.addRule('connection.updateWaypoints', function(context) {
   return {
     type: context.connection.type
   };
 });
46813
 this.addRule('shape.resize', function(context) {
46815
   var shape = context.shape,
       newBounds = context.newBounds;
46818
   return canResize(shape, newBounds);
 });
46821
 this.addRule('elements.create', function(context) {
   var elements = context.elements,
       position = context.position,
       target = context.target;
46826
   if (isConnection$8(target) && !canInsert(elements, target)) {
     return false;
   }
46830
   return every(elements, function(element) {
     if (isConnection$8(element)) {
       return canConnect(element.source, element.target, element);
     }
46835
     if (element.host) {
       return canAttach(element, element.host, null, position);
     }
46839
     return canCreate(element, target, null);
   });
 });
46843
 this.addRule('elements.move', function(context) {
46845
   var target = context.target,
       shapes = context.shapes,
       position = context.position;
46849
   return canAttach(shapes, target, null, position) ||
          canReplace(shapes, target, position) ||
          canMove(shapes, target) ||
          canInsert(shapes, target);
 });
46855
 this.addRule('shape.create', function(context) {
   return canCreate(
     context.shape,
     context.target,
     context.source,
     context.position
   );
 });
46864
 this.addRule('shape.attach', function(context) {
46866
   return canAttach(
     context.shape,
     context.target,
     null,
     context.position
   );
 });
46874
 this.addRule('element.copy', function(context) {
   var element = context.element,
       elements = context.elements;
46878
   return canCopy(elements, element);
 });
};
46882
BpmnRules.prototype.canConnectMessageFlow = canConnectMessageFlow;
46884
BpmnRules.prototype.canConnectSequenceFlow = canConnectSequenceFlow;
46886
BpmnRules.prototype.canConnectDataAssociation = canConnectDataAssociation;
46888
BpmnRules.prototype.canConnectAssociation = canConnectAssociation;
46890
BpmnRules.prototype.canMove = canMove;
46892
BpmnRules.prototype.canAttach = canAttach;
46894
BpmnRules.prototype.canReplace = canReplace;
46896
BpmnRules.prototype.canDrop = canDrop;
46898
BpmnRules.prototype.canInsert = canInsert;
46900
BpmnRules.prototype.canCreate = canCreate;
46902
BpmnRules.prototype.canConnect = canConnect;
46904
BpmnRules.prototype.canResize = canResize;
46906
BpmnRules.prototype.canCopy = canCopy;
46908
/**
* Utility functions for rule checking
*/
46912
/**
* Checks if given element can be used for starting connection.
*
* @param  {Element} source
* @return {boolean}
*/
function canStartConnection(element) {
 if (nonExistingOrLabel(element)) {
   return null;
 }
46923
 return isAny(element, [
   'bpmn:FlowNode',
   'bpmn:InteractionNode',
   'bpmn:DataObjectReference',
   'bpmn:DataStoreReference',
   'bpmn:Group',
   'bpmn:TextAnnotation'
 ]);
}
46933
function nonExistingOrLabel(element) {
 return !element || isLabel$6(element);
}
46937
function isSame$1(a, b) {
 return a === b;
}
46941
function getOrganizationalParent(element) {
46943
 do {
   if (is$1(element, 'bpmn:Process')) {
     return getBusinessObject(element);
   }
46948
   if (is$1(element, 'bpmn:Participant')) {
     return (
       getBusinessObject(element).processRef ||
       getBusinessObject(element)
     );
   }
 } while ((element = element.parent));
46956
}
46958
function isTextAnnotation(element) {
 return is$1(element, 'bpmn:TextAnnotation');
}
46962
function isGroup(element) {
 return is$1(element, 'bpmn:Group') && !element.labelTarget;
}
46966
function isCompensationBoundary(element) {
 return is$1(element, 'bpmn:BoundaryEvent') &&
        hasEventDefinition(element, 'bpmn:CompensateEventDefinition');
}
46971
function isForCompensation(e) {
 return getBusinessObject(e).isForCompensation;
}
46975
function isSameOrganization(a, b) {
 var parentA = getOrganizationalParent(a),
     parentB = getOrganizationalParent(b);
46979
 return parentA === parentB;
}
46982
function isMessageFlowSource(element) {
 return (
   is$1(element, 'bpmn:InteractionNode') &&
   !is$1(element, 'bpmn:BoundaryEvent') && (
     !is$1(element, 'bpmn:Event') || (
       is$1(element, 'bpmn:ThrowEvent') &&
       hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition')
     )
   )
 );
}
46994
function isMessageFlowTarget(element) {
 return (
   is$1(element, 'bpmn:InteractionNode') &&
   !isForCompensation(element) && (
     !is$1(element, 'bpmn:Event') || (
       is$1(element, 'bpmn:CatchEvent') &&
       hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition')
     )
   ) && !(
     is$1(element, 'bpmn:BoundaryEvent') &&
     !hasEventDefinition(element, 'bpmn:MessageEventDefinition')
   )
 );
}
47009
function getScopeParent(element) {
47011
 var parent = element;
47013
 while ((parent = parent.parent)) {
47015
   if (is$1(parent, 'bpmn:FlowElementsContainer')) {
     return getBusinessObject(parent);
   }
47019
   if (is$1(parent, 'bpmn:Participant')) {
     return getBusinessObject(parent).processRef;
   }
 }
47024
 return null;
}
47027
function isSameScope(a, b) {
 var scopeParentA = getScopeParent(a),
     scopeParentB = getScopeParent(b);
47031
 return scopeParentA === scopeParentB;
}
47034
function hasEventDefinition(element, eventDefinition) {
 var bo = getBusinessObject(element);
47037
 return !!find(bo.eventDefinitions || [], function(definition) {
   return is$1(definition, eventDefinition);
 });
}
47042
function hasEventDefinitionOrNone(element, eventDefinition) {
 var bo = getBusinessObject(element);
47045
 return (bo.eventDefinitions || []).every(function(definition) {
   return is$1(definition, eventDefinition);
 });
}
47050
function isSequenceFlowSource(element) {
 return (
   is$1(element, 'bpmn:FlowNode') &&
   !is$1(element, 'bpmn:EndEvent') &&
   !isEventSubProcess(element) &&
   !(is$1(element, 'bpmn:IntermediateThrowEvent') &&
     hasEventDefinition(element, 'bpmn:LinkEventDefinition')
   ) &&
   !isCompensationBoundary(element) &&
   !isForCompensation(element)
 );
}
47063
function isSequenceFlowTarget(element) {
 return (
   is$1(element, 'bpmn:FlowNode') &&
   !is$1(element, 'bpmn:StartEvent') &&
   !is$1(element, 'bpmn:BoundaryEvent') &&
   !isEventSubProcess(element) &&
   !(is$1(element, 'bpmn:IntermediateCatchEvent') &&
     hasEventDefinition(element, 'bpmn:LinkEventDefinition')
   ) &&
   !isForCompensation(element)
 );
}
47076
function isEventBasedTarget(element) {
 return (
   is$1(element, 'bpmn:ReceiveTask') || (
     is$1(element, 'bpmn:IntermediateCatchEvent') && (
       hasEventDefinition(element, 'bpmn:MessageEventDefinition') ||
       hasEventDefinition(element, 'bpmn:TimerEventDefinition') ||
       hasEventDefinition(element, 'bpmn:ConditionalEventDefinition') ||
       hasEventDefinition(element, 'bpmn:SignalEventDefinition')
     )
   )
 );
}
47089
function isConnection$8(element) {
 return element.waypoints;
}
47093
function getParents(element) {
47095
 var parents = [];
47097
 while (element) {
   element = element.parent;
47100
   if (element) {
     parents.push(element);
   }
 }
47105
 return parents;
}
47108
function isParent(possibleParent, element) {
 var allParents = getParents(element);
 return allParents.indexOf(possibleParent) !== -1;
}
47113
function canConnect(source, target, connection) {
47115
 if (nonExistingOrLabel(source) || nonExistingOrLabel(target)) {
   return null;
 }
47119
 if (!is$1(connection, 'bpmn:DataAssociation')) {
47121
   if (canConnectMessageFlow(source, target)) {
     return { type: 'bpmn:MessageFlow' };
   }
47125
   if (canConnectSequenceFlow(source, target)) {
     return { type: 'bpmn:SequenceFlow' };
   }
 }
47130
 var connectDataAssociation = canConnectDataAssociation(source, target);
47132
 if (connectDataAssociation) {
   return connectDataAssociation;
 }
47136
 if (isCompensationBoundary(source) && isForCompensation(target)) {
   return {
     type: 'bpmn:Association',
     associationDirection: 'One'
   };
 }
47143
 if (canConnectAssociation(source, target)) {
47145
   return {
     type: 'bpmn:Association'
   };
 }
47150
 return false;
}
47153
/**
* Can an element be dropped into the target element
*
* @return {boolean}
*/
function canDrop(element, target, position) {
47160
 // can move labels and groups everywhere
 if (isLabel$6(element) || isGroup(element)) {
   return true;
 }
47165
47166
 // disallow to create elements on collapsed pools
 if (is$1(target, 'bpmn:Participant') && !isExpanded(target)) {
   return false;
 }
47171
 // allow to create new participants on
 // existing collaboration and process diagrams
 if (is$1(element, 'bpmn:Participant')) {
   return is$1(target, 'bpmn:Process') || is$1(target, 'bpmn:Collaboration');
 }
47177
 // allow moving DataInput / DataOutput within its original container only
 if (isAny(element, [ 'bpmn:DataInput', 'bpmn:DataOutput' ])) {
47180
   if (element.parent) {
     return target === element.parent;
   }
 }
47185
 // allow creating lanes on participants and other lanes only
 if (is$1(element, 'bpmn:Lane')) {
   return is$1(target, 'bpmn:Participant') || is$1(target, 'bpmn:Lane');
 }
47190
 // disallow dropping boundary events which cannot replace with intermediate event
 if (is$1(element, 'bpmn:BoundaryEvent') && !isDroppableBoundaryEvent(element)) {
   return false;
 }
47195
 // drop flow elements onto flow element containers
 // and participants
 if (is$1(element, 'bpmn:FlowElement') && !is$1(element, 'bpmn:DataStoreReference')) {
   if (is$1(target, 'bpmn:FlowElementsContainer')) {
     return isExpanded(target);
   }
47202
   return isAny(target, [ 'bpmn:Participant', 'bpmn:Lane' ]);
 }
47205
 // disallow dropping data store reference if there is no process to append to
 if (is$1(element, 'bpmn:DataStoreReference') && is$1(target, 'bpmn:Collaboration')) {
   return some(getBusinessObject(target).get('participants'), function(participant) {
     return !!participant.get('processRef');
   });
 }
47212
 // account for the fact that data associations are always
 // rendered and moved to top (Process or Collaboration level)
 //
 // artifacts may be placed wherever, too
 if (isAny(element, [ 'bpmn:Artifact', 'bpmn:DataAssociation', 'bpmn:DataStoreReference' ])) {
   return isAny(target, [
     'bpmn:Collaboration',
     'bpmn:Lane',
     'bpmn:Participant',
     'bpmn:Process',
     'bpmn:SubProcess' ]);
 }
47225
 if (is$1(element, 'bpmn:MessageFlow')) {
   return is$1(target, 'bpmn:Collaboration')
     || element.source.parent == target
     || element.target.parent == target;
 }
47231
 return false;
}
47234
function isDroppableBoundaryEvent(event) {
 return getBusinessObject(event).cancelActivity && (
   hasNoEventDefinition(event) || hasCommonBoundaryIntermediateEventDefinition(event)
 );
}
47240
function isBoundaryEvent(element) {
 return !isLabel$6(element) && is$1(element, 'bpmn:BoundaryEvent');
}
47244
function isLane(element) {
 return is$1(element, 'bpmn:Lane');
}
47248
/**
* We treat IntermediateThrowEvents as boundary events during create,
* this must be reflected in the rules.
*/
function isBoundaryCandidate(element) {
 if (isBoundaryEvent(element)) {
   return true;
 }
47257
 if (is$1(element, 'bpmn:IntermediateThrowEvent') && hasNoEventDefinition(element)) {
   return true;
 }
47261
 return (
   is$1(element, 'bpmn:IntermediateCatchEvent') &&
   hasCommonBoundaryIntermediateEventDefinition(element)
 );
}
47267
function hasNoEventDefinition(element) {
 var bo = getBusinessObject(element);
47270
 return bo && !(bo.eventDefinitions && bo.eventDefinitions.length);
}
47273
function hasCommonBoundaryIntermediateEventDefinition(element) {
 return hasOneOfEventDefinitions(element, [
   'bpmn:MessageEventDefinition',
   'bpmn:TimerEventDefinition',
   'bpmn:SignalEventDefinition',
   'bpmn:ConditionalEventDefinition'
 ]);
}
47282
function hasOneOfEventDefinitions(element, eventDefinitions) {
 return eventDefinitions.some(function(definition) {
   return hasEventDefinition(element, definition);
 });
}
47288
function isReceiveTaskAfterEventBasedGateway(element) {
 return (
   is$1(element, 'bpmn:ReceiveTask') &&
   find(element.incoming, function(incoming) {
     return is$1(incoming.source, 'bpmn:EventBasedGateway');
   })
 );
}
47297
47298
function canAttach(elements, target, source, position) {
47300
 if (!Array.isArray(elements)) {
   elements = [ elements ];
 }
47304
 // only (re-)attach one element at a time
 if (elements.length !== 1) {
   return false;
 }
47309
 var element = elements[0];
47311
 // do not attach labels
 if (isLabel$6(element)) {
   return false;
 }
47316
 // only handle boundary events
 if (!isBoundaryCandidate(element)) {
   return false;
 }
47321
 // disallow drop on event sub processes
 if (isEventSubProcess(target)) {
   return false;
 }
47326
 // only allow drop on non compensation activities
 if (!is$1(target, 'bpmn:Activity') || isForCompensation(target)) {
   return false;
 }
47331
 // only attach to subprocess border
 if (position && !getBoundaryAttachment(position, target)) {
   return false;
 }
47336
 // do not attach on receive tasks after event based gateways
 if (isReceiveTaskAfterEventBasedGateway(target)) {
   return false;
 }
47341
 return 'attach';
}
47344
47345
/**
* Defines how to replace elements for a given target.
*
* Returns an array containing all elements which will be replaced.
*
* @example
*
*  [{ id: 'IntermediateEvent_2',
*     type: 'bpmn:StartEvent'
*   },
*   { id: 'IntermediateEvent_5',
*     type: 'bpmn:EndEvent'
*   }]
*
* @param  {Array} elements
* @param  {Object} target
*
* @return {Object} an object containing all elements which have to be replaced
*/
function canReplace(elements, target, position) {
47366
 if (!target) {
   return false;
 }
47370
 var canExecute = {
   replacements: []
 };
47374
 forEach$2(elements, function(element) {
47376
   if (!isEventSubProcess(target)) {
47378
     if (is$1(element, 'bpmn:StartEvent') &&
         element.type !== 'label' &&
         canDrop(element, target)) {
47382
       // replace a non-interrupting start event by a blank interrupting start event
       // when the target is not an event sub process
       if (!isInterrupting(element)) {
         canExecute.replacements.push({
           oldElementId: element.id,
           newElementType: 'bpmn:StartEvent'
         });
       }
47391
       // replace an error/escalation/compensate start event by a blank interrupting start event
       // when the target is not an event sub process
       if (hasErrorEventDefinition(element) ||
           hasEscalationEventDefinition(element) ||
           hasCompensateEventDefinition(element)) {
         canExecute.replacements.push({
           oldElementId: element.id,
           newElementType: 'bpmn:StartEvent'
         });
       }
47402
       // replace a typed start event by a blank interrupting start event
       // when the target is a sub process but not an event sub process
       if (hasOneOfEventDefinitions(element,
         [
           'bpmn:MessageEventDefinition',
           'bpmn:TimerEventDefinition',
           'bpmn:SignalEventDefinition',
           'bpmn:ConditionalEventDefinition'
         ]) &&
           is$1(target, 'bpmn:SubProcess')) {
         canExecute.replacements.push({
           oldElementId: element.id,
           newElementType: 'bpmn:StartEvent'
         });
       }
     }
   }
47420
   if (!is$1(target, 'bpmn:Transaction')) {
     if (hasEventDefinition(element, 'bpmn:CancelEventDefinition') &&
         element.type !== 'label') {
47424
       if (is$1(element, 'bpmn:EndEvent') && canDrop(element, target)) {
         canExecute.replacements.push({
           oldElementId: element.id,
           newElementType: 'bpmn:EndEvent'
         });
       }
47431
       if (is$1(element, 'bpmn:BoundaryEvent') && canAttach(element, target, null, position)) {
         canExecute.replacements.push({
           oldElementId: element.id,
           newElementType: 'bpmn:BoundaryEvent'
         });
       }
     }
   }
 });
47441
 return canExecute.replacements.length ? canExecute : false;
}
47444
function canMove(elements, target) {
47446
 // do not move selection containing lanes
 if (some(elements, isLane)) {
   return false;
 }
47451
 // allow default move check to start move operation
 if (!target) {
   return true;
 }
47456
 return elements.every(function(element) {
   return canDrop(element, target);
 });
}
47461
function canCreate(shape, target, source, position) {
47463
 if (!target) {
   return false;
 }
47467
 if (isLabel$6(shape) || isGroup(shape)) {
   return true;
 }
47471
 if (isSame$1(source, target)) {
   return false;
 }
47475
 // ensure we do not drop the element
 // into source
 if (source && isParent(source, target)) {
   return false;
 }
47481
 return canDrop(shape, target) || canInsert(shape, target);
}
47484
function canResize(shape, newBounds) {
 if (is$1(shape, 'bpmn:SubProcess')) {
   return (
     isExpanded(shape) && (
       !newBounds || (newBounds.width >= 100 && newBounds.height >= 80)
     )
   );
 }
47493
 if (is$1(shape, 'bpmn:Lane')) {
   return !newBounds || (newBounds.width >= 130 && newBounds.height >= 60);
 }
47497
 if (is$1(shape, 'bpmn:Participant')) {
   return !newBounds || (newBounds.width >= 250 && newBounds.height >= 50);
 }
47501
 if (isTextAnnotation(shape)) {
   return true;
 }
47505
 if (isGroup(shape)) {
   return true;
 }
47509
 return false;
}
47512
/**
* Check, whether one side of the relationship
* is a text annotation.
*/
function isOneTextAnnotation(source, target) {
47518
 var sourceTextAnnotation = isTextAnnotation(source),
     targetTextAnnotation = isTextAnnotation(target);
47521
 return (
   (sourceTextAnnotation || targetTextAnnotation) &&
   (sourceTextAnnotation !== targetTextAnnotation)
 );
}
47527
47528
function canConnectAssociation(source, target) {
47530
 // do not connect connections
 if (isConnection$8(source) || isConnection$8(target)) {
   return false;
 }
47535
 // compensation boundary events are exception
 if (isCompensationBoundary(source) && isForCompensation(target)) {
   return true;
 }
47540
 // don't connect parent <-> child
 if (isParent(target, source) || isParent(source, target)) {
   return false;
 }
47545
 // allow connection of associations between <!TextAnnotation> and <TextAnnotation>
 if (isOneTextAnnotation(source, target)) {
   return true;
 }
47550
 // can connect associations where we can connect
 // data associations, too (!)
 return !!canConnectDataAssociation(source, target);
}
47555
function canConnectMessageFlow(source, target) {
47557
 // during connect user might move mouse out of canvas
 // https://github.com/bpmn-io/bpmn-js/issues/1033
 if (getRootElement(source) && !getRootElement(target)) {
   return false;
 }
47563
 return (
   isMessageFlowSource(source) &&
   isMessageFlowTarget(target) &&
   !isSameOrganization(source, target)
 );
}
47570
function canConnectSequenceFlow(source, target) {
47572
 if (
   isEventBasedTarget(target) &&
   target.incoming.length > 0 &&
   areOutgoingEventBasedGatewayConnections(target.incoming) &&
   !is$1(source, 'bpmn:EventBasedGateway')
 ) {
   return false;
 }
47581
 return isSequenceFlowSource(source) &&
        isSequenceFlowTarget(target) &&
        isSameScope(source, target) &&
        !(is$1(source, 'bpmn:EventBasedGateway') && !isEventBasedTarget(target));
}
47587
47588
function canConnectDataAssociation(source, target) {
47590
 if (isAny(source, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ]) &&
     isAny(target, [ 'bpmn:Activity', 'bpmn:ThrowEvent' ])) {
   return { type: 'bpmn:DataInputAssociation' };
 }
47595
 if (isAny(target, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ]) &&
     isAny(source, [ 'bpmn:Activity', 'bpmn:CatchEvent' ])) {
   return { type: 'bpmn:DataOutputAssociation' };
 }
47600
 return false;
}
47603
function canInsert(shape, flow, position) {
47605
 if (!flow) {
   return false;
 }
47609
 if (Array.isArray(shape)) {
   if (shape.length !== 1) {
     return false;
   }
47614
   shape = shape[0];
 }
47617
 if (flow.source === shape ||
     flow.target === shape) {
   return false;
 }
47622
 // return true if we can drop on the
 // underlying flow parent
 //
 // at this point we are not really able to talk
 // about connection rules (yet)
47628
 return (
   isAny(flow, [ 'bpmn:SequenceFlow', 'bpmn:MessageFlow' ]) &&
   !isLabel$6(flow) &&
   is$1(shape, 'bpmn:FlowNode') &&
   !is$1(shape, 'bpmn:BoundaryEvent') &&
   canDrop(shape, flow.parent));
}
47636
function includes$5(elements, element) {
 return (elements && element) && elements.indexOf(element) !== -1;
}
47640
function canCopy(elements, element) {
 if (isLabel$6(element)) {
   return true;
 }
47645
 if (is$1(element, 'bpmn:Lane') && !includes$5(elements, element.parent)) {
   return false;
 }
47649
 return true;
}
47652
function isOutgoingEventBasedGatewayConnection(connection) {
47654
 if (connection && connection.source) {
   return is$1(connection.source, 'bpmn:EventBasedGateway');
 }
}
47659
function areOutgoingEventBasedGatewayConnections(connections) {
 connections = connections || [];
47662
 return connections.some(isOutgoingEventBasedGatewayConnection);
}
47665
function getRootElement(element) {
 return getParent(element, 'bpmn:Process') || getParent(element, 'bpmn:Collaboration');
}
47669
var RulesModule = {
 __depends__: [
   RulesModule$1
 ],
 __init__: [ 'bpmnRules' ],
 bpmnRules: [ 'type', BpmnRules ]
};
47677
var HIGH_PRIORITY$6 = 2000;
47679
function BpmnDiOrdering(eventBus, canvas) {
47681
 eventBus.on('saveXML.start', HIGH_PRIORITY$6, orderDi);
47683
 function orderDi() {
   var rootElements = canvas.getRootElements();
47686
   forEach$2(rootElements, function(root) {
     var rootDi = getDi(root),
         elements,
         diElements;
47691
     elements = selfAndAllChildren([ root ], false);
47693
     // only bpmndi:Shape and bpmndi:Edge can be direct children of bpmndi:Plane
     elements = filter(elements, function(element) {
       return element !== root && !element.labelTarget;
     });
47698
     diElements = map(elements, getDi);
47700
     rootDi.set('planeElement', diElements);
   });
 }
}
47705
BpmnDiOrdering.$inject = [ 'eventBus', 'canvas' ];
47707
var DiOrderingModule = {
 __init__: [
   'bpmnDiOrdering'
 ],
 bpmnDiOrdering: [ 'type', BpmnDiOrdering ]
};
47714
/**
* An abstract provider that allows modelers to implement a custom
* ordering of diagram elements on the canvas.
*
* It makes sure that the order is always preserved during element
* creation and move operations.
*
* In order to use this behavior, inherit from it and override
* the method {@link OrderingProvider#getOrdering}.
*
* @example
*
* ```javascript
* function CustomOrderingProvider(eventBus) {
*   OrderingProvider.call(this, eventBus);
*
*   this.getOrdering = function(element, newParent) {
*     // always insert elements at the front
*     // when moving
*     return {
*       index: 0,
*       parent: newParent
*     };
*   };
* }
* ```
*
* @param {EventBus} eventBus
*/
function OrderingProvider(eventBus) {
47745
 CommandInterceptor.call(this, eventBus);
47747
47748
 var self = this;
47750
 this.preExecute([ 'shape.create', 'connection.create' ], function(event) {
47752
   var context = event.context,
       element = context.shape || context.connection,
       parent = context.parent;
47756
   var ordering = self.getOrdering(element, parent);
47758
   if (ordering) {
47760
     if (ordering.parent !== undefined) {
       context.parent = ordering.parent;
     }
47764
     context.parentIndex = ordering.index;
   }
 });
47768
 this.preExecute([ 'shape.move', 'connection.move' ], function(event) {
47770
   var context = event.context,
       element = context.shape || context.connection,
       parent = context.newParent || element.parent;
47774
   var ordering = self.getOrdering(element, parent);
47776
   if (ordering) {
47778
     if (ordering.parent !== undefined) {
       context.newParent = ordering.parent;
     }
47782
     context.newParentIndex = ordering.index;
   }
 });
}
47787
/**
* Return a custom ordering of the element, both in terms
* of parent element and index in the new parent.
*
* Implementors of this method must return an object with
* `parent` _and_ `index` in it.
*
* @param {djs.model.Base} element
* @param {djs.model.Shape} newParent
*
* @return {Object} ordering descriptor
*/
OrderingProvider.prototype.getOrdering = function(element, newParent) {
 return null;
};
47803
inherits$1(OrderingProvider, CommandInterceptor);
47805
/**
* a simple ordering provider that makes sure:
*
* (0) labels and groups are rendered always on top
* (1) elements are ordered by a {level} property
*/
function BpmnOrderingProvider(eventBus, canvas, translate) {
47813
 OrderingProvider.call(this, eventBus);
47815
 var orders = [
   { type: 'bpmn:SubProcess', order: { level: 6 } },
   {
     type: 'bpmn:SequenceFlow',
     order: {
       level: 3,
       containers: [
         'bpmn:Participant',
         'bpmn:FlowElementsContainer'
       ]
     }
   },
47828
   // handle DataAssociation(s) like message flows and render them always on top
   {
     type: 'bpmn:DataAssociation',
     order: {
       level: 9,
       containers: [
         'bpmn:Collaboration',
         'bpmn:FlowElementsContainer'
       ]
     }
   },
   {
     type: 'bpmn:MessageFlow', order: {
       level: 9,
       containers: [ 'bpmn:Collaboration' ]
     }
   },
   {
     type: 'bpmn:Association',
     order: {
       level: 6,
       containers: [
         'bpmn:Participant',
         'bpmn:FlowElementsContainer',
         'bpmn:Collaboration'
       ]
     }
   },
   { type: 'bpmn:BoundaryEvent', order: { level: 8 } },
   {
     type: 'bpmn:Group',
     order: {
       level: 10,
       containers: [
         'bpmn:Collaboration',
         'bpmn:FlowElementsContainer'
       ]
     }
   },
   { type: 'bpmn:FlowElement', order: { level: 5 } },
   { type: 'bpmn:Participant', order: { level: -2 } },
   { type: 'bpmn:Lane', order: { level: -1 } }
 ];
47872
 function computeOrder(element) {
   if (element.labelTarget) {
     return { level: 10 };
   }
47877
   var entry = find(orders, function(o) {
     return isAny(element, [ o.type ]);
   });
47881
   return entry && entry.order || { level: 1 };
 }
47884
 function getOrder(element) {
47886
   var order = element.order;
47888
   if (!order) {
     element.order = order = computeOrder(element);
   }
47892
   if (!order) {
     throw new Error('no order for <' + element.id + '>');
   }
47896
   return order;
 }
47899
 function findActualParent(element, newParent, containers) {
47901
   var actualParent = newParent;
47903
   while (actualParent) {
47905
     if (isAny(actualParent, containers)) {
       break;
     }
47909
     actualParent = actualParent.parent;
   }
47912
   if (!actualParent) {
     throw new Error('no parent for <' + element.id + '> in <' + (newParent && newParent.id) + '>');
   }
47916
   return actualParent;
 }
47919
 this.getOrdering = function(element, newParent) {
47921
   // render labels always on top
   if (element.labelTarget) {
     return {
       parent: canvas.findRoot(newParent) || canvas.getRootElement(),
       index: -1
     };
   }
47929
   var elementOrder = getOrder(element);
47931
   if (elementOrder.containers) {
     newParent = findActualParent(element, newParent, elementOrder.containers);
   }
47935
   var currentIndex = newParent.children.indexOf(element);
47937
   var insertIndex = findIndex(newParent.children, function(child) {
47939
     // do not compare with labels, they are created
     // in the wrong order (right after elements) during import and
     // mess up the positioning.
     if (!element.labelTarget && child.labelTarget) {
       return false;
     }
47946
     return elementOrder.level < getOrder(child).level;
   });
47949
47950
   // if the element is already in the child list at
   // a smaller index, we need to adjust the insert index.
   // this takes into account that the element is being removed
   // before being re-inserted
   if (insertIndex !== -1) {
     if (currentIndex !== -1 && currentIndex < insertIndex) {
       insertIndex -= 1;
     }
   }
47960
   return {
     index: insertIndex,
     parent: newParent
   };
 };
}
47967
BpmnOrderingProvider.$inject = [ 'eventBus', 'canvas', 'translate' ];
47969
inherits$1(BpmnOrderingProvider, OrderingProvider);
47971
var OrderingModule = {
 __depends__: [
   translate
 ],
 __init__: [ 'bpmnOrderingProvider' ],
 bpmnOrderingProvider: [ 'type', BpmnOrderingProvider ]
};
47979
/**
* A service that offers un- and redoable execution of commands.
*
* The command stack is responsible for executing modeling actions
* in a un- and redoable manner. To do this it delegates the actual
* command execution to {@link CommandHandler}s.
*
* Command handlers provide {@link CommandHandler#execute(ctx)} and
* {@link CommandHandler#revert(ctx)} methods to un- and redo a command
* identified by a command context.
*
*
* ## Life-Cycle events
*
* In the process the command stack fires a number of life-cycle events
* that other components to participate in the command execution.
*
*    * preExecute
*    * preExecuted
*    * execute
*    * executed
*    * postExecute
*    * postExecuted
*    * revert
*    * reverted
*
* A special event is used for validating, whether a command can be
* performed prior to its execution.
*
*    * canExecute
*
* Each of the events is fired as `commandStack.{eventName}` and
* `commandStack.{commandName}.{eventName}`, respectively. This gives
* components fine grained control on where to hook into.
*
* The event object fired transports `command`, the name of the
* command and `context`, the command context.
*
*
* ## Creating Command Handlers
*
* Command handlers should provide the {@link CommandHandler#execute(ctx)}
* and {@link CommandHandler#revert(ctx)} methods to implement
* redoing and undoing of a command.
*
* A command handler _must_ ensure undo is performed properly in order
* not to break the undo chain. It must also return the shapes that
* got changed during the `execute` and `revert` operations.
*
* Command handlers may execute other modeling operations (and thus
* commands) in their `preExecute` and `postExecute` phases. The command
* stack will properly group all commands together into a logical unit
* that may be re- and undone atomically.
*
* Command handlers must not execute other commands from within their
* core implementation (`execute`, `revert`).
*
*
* ## Change Tracking
*
* During the execution of the CommandStack it will keep track of all
* elements that have been touched during the command's execution.
*
* At the end of the CommandStack execution it will notify interested
* components via an 'elements.changed' event with all the dirty
* elements.
*
* The event can be picked up by components that are interested in the fact
* that elements have been changed. One use case for this is updating
* their graphical representation after moving / resizing or deletion.
*
* @see CommandHandler
*
* @param {EventBus} eventBus
* @param {Injector} injector
*/
function CommandStack(eventBus, injector) {
48057
 /**
  * A map of all registered command handlers.
  *
  * @type {Object}
  */
 this._handlerMap = {};
48064
 /**
  * A stack containing all re/undoable actions on the diagram
  *
  * @type {Array<Object>}
  */
 this._stack = [];
48071
 /**
  * The current index on the stack
  *
  * @type {number}
  */
 this._stackIdx = -1;
48078
 /**
  * Current active commandStack execution
  *
  * @type {Object}
  * @property {Object[]} actions
  * @property {Object[]} dirty
  * @property { 'undo' | 'redo' | 'clear' | 'execute' | null } trigger the cause of the current excecution
  */
 this._currentExecution = {
   actions: [],
   dirty: [],
   trigger: null
 };
48092
48093
 this._injector = injector;
 this._eventBus = eventBus;
48096
 this._uid = 1;
48098
 eventBus.on([
   'diagram.destroy',
   'diagram.clear'
 ], function() {
   this.clear(false);
 }, this);
}
48106
CommandStack.$inject = [ 'eventBus', 'injector' ];
48108
48109
/**
* Execute a command
*
* @param {string} command the command to execute
* @param {Object} context the environment to execute the command in
*/
CommandStack.prototype.execute = function(command, context) {
 if (!command) {
   throw new Error('command required');
 }
48120
 this._currentExecution.trigger = 'execute';
48122
 var action = { command: command, context: context };
48124
 this._pushAction(action);
 this._internalExecute(action);
 this._popAction(action);
};
48129
48130
/**
* Ask whether a given command can be executed.
*
* Implementors may hook into the mechanism on two ways:
*
*   * in event listeners:
*
*     Users may prevent the execution via an event listener.
*     It must prevent the default action for `commandStack.(<command>.)canExecute` events.
*
*   * in command handlers:
*
*     If the method {@link CommandHandler#canExecute} is implemented in a handler
*     it will be called to figure out whether the execution is allowed.
*
* @param  {string} command the command to execute
* @param  {Object} context the environment to execute the command in
*
* @return {boolean} true if the command can be executed
*/
CommandStack.prototype.canExecute = function(command, context) {
48152
 var action = { command: command, context: context };
48154
 var handler = this._getHandler(command);
48156
 var result = this._fire(command, 'canExecute', action);
48158
 // handler#canExecute will only be called if no listener
 // decided on a result already
 if (result === undefined) {
   if (!handler) {
     return false;
   }
48165
   if (handler.canExecute) {
     result = handler.canExecute(context);
   }
 }
48170
 return result;
};
48173
48174
/**
* Clear the command stack, erasing all undo / redo history
*/
CommandStack.prototype.clear = function(emit) {
 this._stack.length = 0;
 this._stackIdx = -1;
48181
 if (emit !== false) {
   this._fire('changed', { trigger: 'clear' });
 }
};
48186
48187
/**
* Undo last command(s)
*/
CommandStack.prototype.undo = function() {
 var action = this._getUndoAction(),
     next;
48194
 if (action) {
   this._currentExecution.trigger = 'undo';
48197
   this._pushAction(action);
48199
   while (action) {
     this._internalUndo(action);
     next = this._getUndoAction();
48203
     if (!next || next.id !== action.id) {
       break;
     }
48207
     action = next;
   }
48210
   this._popAction();
 }
};
48214
48215
/**
* Redo last command(s)
*/
CommandStack.prototype.redo = function() {
 var action = this._getRedoAction(),
     next;
48222
 if (action) {
   this._currentExecution.trigger = 'redo';
48225
   this._pushAction(action);
48227
   while (action) {
     this._internalExecute(action, true);
     next = this._getRedoAction();
48231
     if (!next || next.id !== action.id) {
       break;
     }
48235
     action = next;
   }
48238
   this._popAction();
 }
};
48242
48243
/**
* Register a handler instance with the command stack
*
* @param {string} command
* @param {CommandHandler} handler
*/
CommandStack.prototype.register = function(command, handler) {
 this._setHandler(command, handler);
};
48253
48254
/**
* Register a handler type with the command stack
* by instantiating it and injecting its dependencies.
*
* @param {string} command
* @param {Function} a constructor for a {@link CommandHandler}
*/
CommandStack.prototype.registerHandler = function(command, handlerCls) {
48263
 if (!command || !handlerCls) {
   throw new Error('command and handlerCls must be defined');
 }
48267
 var handler = this._injector.instantiate(handlerCls);
 this.register(command, handler);
};
48271
CommandStack.prototype.canUndo = function() {
 return !!this._getUndoAction();
};
48275
CommandStack.prototype.canRedo = function() {
 return !!this._getRedoAction();
};
48279
// stack access  //////////////////////
48281
CommandStack.prototype._getRedoAction = function() {
 return this._stack[this._stackIdx + 1];
};
48285
48286
CommandStack.prototype._getUndoAction = function() {
 return this._stack[this._stackIdx];
};
48290
48291
// internal functionality //////////////////////
48293
CommandStack.prototype._internalUndo = function(action) {
 var self = this;
48296
 var command = action.command,
     context = action.context;
48299
 var handler = this._getHandler(command);
48301
 // guard against illegal nested command stack invocations
 this._atomicDo(function() {
   self._fire(command, 'revert', action);
48305
   if (handler.revert) {
     self._markDirty(handler.revert(context));
   }
48309
   self._revertedAction(action);
48311
   self._fire(command, 'reverted', action);
 });
};
48315
48316
CommandStack.prototype._fire = function(command, qualifier, event) {
 if (arguments.length < 3) {
   event = qualifier;
   qualifier = null;
 }
48322
 var names = qualifier ? [ command + '.' + qualifier, qualifier ] : [ command ],
     i, name, result;
48325
 event = this._eventBus.createEvent(event);
48327
 for (i = 0; (name = names[i]); i++) {
   result = this._eventBus.fire('commandStack.' + name, event);
48330
   if (event.cancelBubble) {
     break;
   }
 }
48335
 return result;
};
48338
CommandStack.prototype._createId = function() {
 return this._uid++;
};
48342
CommandStack.prototype._atomicDo = function(fn) {
48344
 var execution = this._currentExecution;
48346
 execution.atomic = true;
48348
 try {
   fn();
 } finally {
   execution.atomic = false;
 }
};
48355
CommandStack.prototype._internalExecute = function(action, redo) {
 var self = this;
48358
 var command = action.command,
     context = action.context;
48361
 var handler = this._getHandler(command);
48363
 if (!handler) {
   throw new Error('no command handler registered for <' + command + '>');
 }
48367
 this._pushAction(action);
48369
 if (!redo) {
   this._fire(command, 'preExecute', action);
48372
   if (handler.preExecute) {
     handler.preExecute(context);
   }
48376
   this._fire(command, 'preExecuted', action);
 }
48379
 // guard against illegal nested command stack invocations
 this._atomicDo(function() {
48382
   self._fire(command, 'execute', action);
48384
   if (handler.execute) {
48386
     // actual execute + mark return results as dirty
     self._markDirty(handler.execute(context));
   }
48390
   // log to stack
   self._executedAction(action, redo);
48393
   self._fire(command, 'executed', action);
 });
48396
 if (!redo) {
   this._fire(command, 'postExecute', action);
48399
   if (handler.postExecute) {
     handler.postExecute(context);
   }
48403
   this._fire(command, 'postExecuted', action);
 }
48406
 this._popAction(action);
};
48409
48410
CommandStack.prototype._pushAction = function(action) {
48412
 var execution = this._currentExecution,
     actions = execution.actions;
48415
 var baseAction = actions[0];
48417
 if (execution.atomic) {
   throw new Error('illegal invocation in <execute> or <revert> phase (action: ' + action.command + ')');
 }
48421
 if (!action.id) {
   action.id = (baseAction && baseAction.id) || this._createId();
 }
48425
 actions.push(action);
};
48428
48429
CommandStack.prototype._popAction = function() {
 var execution = this._currentExecution,
     trigger = execution.trigger,
     actions = execution.actions,
     dirty = execution.dirty;
48435
 actions.pop();
48437
 if (!actions.length) {
   this._eventBus.fire('elements.changed', { elements: uniqueBy('id', dirty.reverse()) });
48440
   dirty.length = 0;
48442
   this._fire('changed', { trigger: trigger });
48444
   execution.trigger = null;
 }
};
48448
48449
CommandStack.prototype._markDirty = function(elements) {
 var execution = this._currentExecution;
48452
 if (!elements) {
   return;
 }
48456
 elements = isArray$4(elements) ? elements : [ elements ];
48458
 execution.dirty = execution.dirty.concat(elements);
};
48461
48462
CommandStack.prototype._executedAction = function(action, redo) {
 var stackIdx = ++this._stackIdx;
48465
 if (!redo) {
   this._stack.splice(stackIdx, this._stack.length, action);
 }
};
48470
48471
CommandStack.prototype._revertedAction = function(action) {
 this._stackIdx--;
};
48475
48476
CommandStack.prototype._getHandler = function(command) {
 return this._handlerMap[command];
};
48480
CommandStack.prototype._setHandler = function(command, handler) {
 if (!command || !handler) {
   throw new Error('command and handler required');
 }
48485
 if (this._handlerMap[command]) {
   throw new Error('overriding handler for command <' + command + '>');
 }
48489
 this._handlerMap[command] = handler;
};
48492
var CommandModule = {
 commandStack: [ 'type', CommandStack ]
};
48496
// document wide unique tooltip ids
var ids = new IdGenerator('tt');
48499
48500
function createRoot(parentNode) {
 var root = domify(
   '<div class="djs-tooltip-container" />'
 );
48505
 assign$1(root, {
   position: 'absolute',
   width: '0',
   height: '0'
 });
48511
 parentNode.insertBefore(root, parentNode.firstChild);
48513
 return root;
}
48516
48517
function setPosition(el, x, y) {
 assign$1(el, { left: x + 'px', top: y + 'px' });
}
48521
function setVisible(el, visible) {
 el.style.display = visible === false ? 'none' : '';
}
48525
48526
var tooltipClass = 'djs-tooltip',
   tooltipSelector = '.' + tooltipClass;
48529
/**
* A service that allows users to render tool tips on the diagram.
*
* The tooltip service will take care of updating the tooltip positioning
* during navigation + zooming.
*
* @example
*
* ```javascript
*
* // add a pink badge on the top left of the shape
* tooltips.add({
*   position: {
*     x: 50,
*     y: 100
*   },
*   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>'
* });
*
* // or with optional life span
* tooltips.add({
*   position: {
*     top: -5,
*     left: -5
*   },
*   html: '<div style="width: 10px; background: fuchsia; color: white;">0</div>',
*   ttl: 2000
* });
*
* // remove a tool tip
* var id = tooltips.add(...);
* tooltips.remove(id);
* ```
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
*/
function Tooltips(eventBus, canvas) {
48568
 this._eventBus = eventBus;
 this._canvas = canvas;
48571
 this._ids = ids;
48573
 this._tooltipDefaults = {
   show: {
     minZoom: 0.7,
     maxZoom: 5.0
   }
 };
48580
 /**
  * Mapping tooltipId -> tooltip
  */
 this._tooltips = {};
48585
 // root html element for all tooltips
 this._tooltipRoot = createRoot(canvas.getContainer());
48588
48589
 var self = this;
48591
 delegate.bind(this._tooltipRoot, tooltipSelector, 'mousedown', function(event) {
   event.stopPropagation();
 });
48595
 delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseover', function(event) {
   self.trigger('mouseover', event);
 });
48599
 delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseout', function(event) {
   self.trigger('mouseout', event);
 });
48603
 this._init();
}
48606
48607
Tooltips.$inject = [ 'eventBus', 'canvas' ];
48609
48610
/**
* Adds a HTML tooltip to the diagram
*
* @param {Object}               tooltip   the tooltip configuration
*
* @param {string|DOMElement}    tooltip.html                 html element to use as an tooltip
* @param {Object}               [tooltip.show]               show configuration
* @param {number}               [tooltip.show.minZoom]       minimal zoom level to show the tooltip
* @param {number}               [tooltip.show.maxZoom]       maximum zoom level to show the tooltip
* @param {Object}               tooltip.position             where to attach the tooltip
* @param {number}               [tooltip.position.left]      relative to element bbox left attachment
* @param {number}               [tooltip.position.top]       relative to element bbox top attachment
* @param {number}               [tooltip.position.bottom]    relative to element bbox bottom attachment
* @param {number}               [tooltip.position.right]     relative to element bbox right attachment
* @param {number}               [tooltip.timeout=-1]
*
* @return {string}              id that may be used to reference the tooltip for update or removal
*/
Tooltips.prototype.add = function(tooltip) {
48630
 if (!tooltip.position) {
   throw new Error('must specifiy tooltip position');
 }
48634
 if (!tooltip.html) {
   throw new Error('must specifiy tooltip html');
 }
48638
 var id = this._ids.next();
48640
 tooltip = assign({}, this._tooltipDefaults, tooltip, {
   id: id
 });
48644
 this._addTooltip(tooltip);
48646
 if (tooltip.timeout) {
   this.setTimeout(tooltip);
 }
48650
 return id;
};
48653
Tooltips.prototype.trigger = function(action, event) {
48655
 var node = event.delegateTarget || event.target;
48657
 var tooltip = this.get(attr(node, 'data-tooltip-id'));
48659
 if (!tooltip) {
   return;
 }
48663
 if (action === 'mouseover' && tooltip.timeout) {
   this.clearTimeout(tooltip);
 }
48667
 if (action === 'mouseout' && tooltip.timeout) {
48669
   // cut timeout after mouse out
   tooltip.timeout = 1000;
48672
   this.setTimeout(tooltip);
 }
};
48676
/**
* Get a tooltip with the given id
*
* @param {string} id
*/
Tooltips.prototype.get = function(id) {
48683
 if (typeof id !== 'string') {
   id = id.id;
 }
48687
 return this._tooltips[id];
};
48690
Tooltips.prototype.clearTimeout = function(tooltip) {
48692
 tooltip = this.get(tooltip);
48694
 if (!tooltip) {
   return;
 }
48698
 var removeTimer = tooltip.removeTimer;
48700
 if (removeTimer) {
   clearTimeout(removeTimer);
   tooltip.removeTimer = null;
 }
};
48706
Tooltips.prototype.setTimeout = function(tooltip) {
48708
 tooltip = this.get(tooltip);
48710
 if (!tooltip) {
   return;
 }
48714
 this.clearTimeout(tooltip);
48716
 var self = this;
48718
 tooltip.removeTimer = setTimeout(function() {
   self.remove(tooltip);
 }, tooltip.timeout);
};
48723
/**
* Remove an tooltip with the given id
*
* @param {string} id
*/
Tooltips.prototype.remove = function(id) {
48730
 var tooltip = this.get(id);
48732
 if (tooltip) {
   remove$1(tooltip.html);
   remove$1(tooltip.htmlContainer);
48736
   delete tooltip.htmlContainer;
48738
   delete this._tooltips[tooltip.id];
 }
};
48742
48743
Tooltips.prototype.show = function() {
 setVisible(this._tooltipRoot);
};
48747
48748
Tooltips.prototype.hide = function() {
 setVisible(this._tooltipRoot, false);
};
48752
48753
Tooltips.prototype._updateRoot = function(viewbox) {
 var a = viewbox.scale || 1;
 var d = viewbox.scale || 1;
48757
 var matrix = 'matrix(' + a + ',0,0,' + d + ',' + (-1 * viewbox.x * a) + ',' + (-1 * viewbox.y * d) + ')';
48759
 this._tooltipRoot.style.transform = matrix;
 this._tooltipRoot.style['-ms-transform'] = matrix;
};
48763
48764
Tooltips.prototype._addTooltip = function(tooltip) {
48766
 var id = tooltip.id,
     html = tooltip.html,
     htmlContainer,
     tooltipRoot = this._tooltipRoot;
48771
 // unwrap jquery (for those who need it)
 if (html.get && html.constructor.prototype.jquery) {
   html = html.get(0);
 }
48776
 // create proper html elements from
 // tooltip HTML strings
 if (isString(html)) {
   html = domify(html);
 }
48782
 htmlContainer = domify('<div data-tooltip-id="' + id + '" class="' + tooltipClass + '">');
 assign$1(htmlContainer, { position: 'absolute' });
48785
 htmlContainer.appendChild(html);
48787
 if (tooltip.type) {
   classes(htmlContainer).add('djs-tooltip-' + tooltip.type);
 }
48791
 if (tooltip.className) {
   classes(htmlContainer).add(tooltip.className);
 }
48795
 tooltip.htmlContainer = htmlContainer;
48797
 tooltipRoot.appendChild(htmlContainer);
48799
 this._tooltips[id] = tooltip;
48801
 this._updateTooltip(tooltip);
};
48804
48805
Tooltips.prototype._updateTooltip = function(tooltip) {
48807
 var position = tooltip.position,
     htmlContainer = tooltip.htmlContainer;
48810
 // update overlay html based on tooltip x, y
48812
 setPosition(htmlContainer, position.x, position.y);
};
48815
48816
Tooltips.prototype._updateTooltipVisibilty = function(viewbox) {
48818
 forEach$2(this._tooltips, function(tooltip) {
   var show = tooltip.show,
       htmlContainer = tooltip.htmlContainer,
       visible = true;
48823
   if (show) {
     if (show.minZoom > viewbox.scale ||
         show.maxZoom < viewbox.scale) {
       visible = false;
     }
48829
     setVisible(htmlContainer, visible);
   }
 });
};
48834
Tooltips.prototype._init = function() {
48836
 var self = this;
48838
 // scroll/zoom integration
48840
 function updateViewbox(viewbox) {
   self._updateRoot(viewbox);
   self._updateTooltipVisibilty(viewbox);
48844
   self.show();
 }
48847
 this._eventBus.on('canvas.viewbox.changing', function(event) {
   self.hide();
 });
48851
 this._eventBus.on('canvas.viewbox.changed', function(event) {
   updateViewbox(event.viewbox);
 });
};
48856
var TooltipsModule = {
 __init__: [ 'tooltips' ],
 tooltips: [ 'type', Tooltips ]
};
48861
/**
* Remove from the beginning of a collection until it is empty.
*
* This is a null-safe operation that ensures elements
* are being removed from the given collection until the
* collection is empty.
*
* The implementation deals with the fact that a remove operation
* may touch, i.e. remove multiple elements in the collection
* at a time.
*
* @param {Array<Object>} [collection]
* @param {Function} removeFn
*
* @return {Array<Object>} the cleared collection
*/
function saveClear(collection, removeFn) {
48879
 if (typeof removeFn !== 'function') {
   throw new Error('removeFn iterator must be a function');
 }
48883
 if (!collection) {
   return;
 }
48887
 var e;
48889
 while ((e = collection[0])) {
   removeFn(e);
 }
48893
 return collection;
}
48896
var LOW_PRIORITY$6 = 250,
   HIGH_PRIORITY$5 = 1400;
48899
48900
/**
* A handler that makes sure labels are properly moved with
* their label targets.
*
* @param {didi.Injector} injector
* @param {EventBus} eventBus
* @param {Modeling} modeling
*/
function LabelSupport(injector, eventBus, modeling) {
48910
 CommandInterceptor.call(this, eventBus);
48912
 var movePreview = injector.get('movePreview', false);
48914
 // remove labels from the collection that are being
 // moved with other elements anyway
 eventBus.on('shape.move.start', HIGH_PRIORITY$5, function(e) {
48918
   var context = e.context,
       shapes = context.shapes,
       validatedShapes = context.validatedShapes;
48922
   context.shapes = removeLabels(shapes);
   context.validatedShapes = removeLabels(validatedShapes);
 });
48926
 // add labels to visual's group
 movePreview && eventBus.on('shape.move.start', LOW_PRIORITY$6, function(e) {
48929
   var context = e.context,
       shapes = context.shapes;
48932
   var labels = [];
48934
   forEach$2(shapes, function(element) {
48936
     forEach$2(element.labels, function(label) {
48938
       if (!label.hidden && context.shapes.indexOf(label) === -1) {
         labels.push(label);
       }
48942
       if (element.labelTarget) {
         labels.push(element);
       }
     });
   });
48948
   forEach$2(labels, function(label) {
     movePreview.makeDraggable(context, label, true);
   });
48952
 });
48954
 // add all labels to move closure
 this.preExecuted('elements.move', HIGH_PRIORITY$5, function(e) {
   var context = e.context,
       closure = context.closure,
       enclosedElements = closure.enclosedElements;
48960
   var enclosedLabels = [];
48962
   // find labels that are not part of
   // move closure yet and add them
   forEach$2(enclosedElements, function(element) {
     forEach$2(element.labels, function(label) {
48967
       if (!enclosedElements[label.id]) {
         enclosedLabels.push(label);
       }
     });
   });
48973
   closure.addAll(enclosedLabels);
 });
48976
48977
 this.preExecute([
   'connection.delete',
   'shape.delete'
 ], function(e) {
48982
   var context = e.context,
       element = context.connection || context.shape;
48985
   saveClear(element.labels, function(label) {
     modeling.removeShape(label, { nested: true });
   });
 });
48990
48991
 this.execute('shape.delete', function(e) {
48993
   var context = e.context,
       shape = context.shape,
       labelTarget = shape.labelTarget;
48997
   // unset labelTarget
   if (labelTarget) {
     context.labelTargetIndex = indexOf(labelTarget.labels, shape);
     context.labelTarget = labelTarget;
49002
     shape.labelTarget = null;
   }
 });
49006
 this.revert('shape.delete', function(e) {
49008
   var context = e.context,
       shape = context.shape,
       labelTarget = context.labelTarget,
       labelTargetIndex = context.labelTargetIndex;
49013
   // restore labelTarget
   if (labelTarget) {
     add(labelTarget.labels, shape, labelTargetIndex);
49017
     shape.labelTarget = labelTarget;
   }
 });
49021
}
49023
inherits$1(LabelSupport, CommandInterceptor);
49025
LabelSupport.$inject = [
 'injector',
 'eventBus',
 'modeling'
];
49031
49032
/**
* Return a filtered list of elements that do not
* contain attached elements with hosts being part
* of the selection.
*
* @param  {Array<djs.model.Base>} elements
*
* @return {Array<djs.model.Base>} filtered
*/
function removeLabels(elements) {
49043
 return filter(elements, function(element) {
49045
   // filter out labels that are move together
   // with their label targets
   return elements.indexOf(element.labelTarget) === -1;
 });
}
49051
var LabelSupportModule = {
 __init__: [ 'labelSupport' ],
 labelSupport: [ 'type', LabelSupport ]
};
49056
var LOW_PRIORITY$5 = 251,
   HIGH_PRIORITY$4 = 1401;
49059
var MARKER_ATTACH$1 = 'attach-ok';
49061
49062
/**
* Adds the notion of attached elements to the modeler.
*
* Optionally depends on `diagram-js/lib/features/move` to render
* the attached elements during move preview.
*
* Optionally depends on `diagram-js/lib/features/label-support`
* to render attached labels during move preview.
*
* @param {didi.Injector} injector
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {Rules} rules
* @param {Modeling} modeling
*/
function AttachSupport(injector, eventBus, canvas, rules, modeling) {
49079
 CommandInterceptor.call(this, eventBus);
49081
 var movePreview = injector.get('movePreview', false);
49083
49084
 // remove all the attached elements from the shapes to be validated
 // add all the attached shapes to the overall list of moved shapes
 eventBus.on('shape.move.start', HIGH_PRIORITY$4, function(e) {
49088
   var context = e.context,
       shapes = context.shapes,
       validatedShapes = context.validatedShapes;
49092
   context.shapes = addAttached(shapes);
49094
   context.validatedShapes = removeAttached(validatedShapes);
 });
49097
 // add attachers to the visual's group
 movePreview && eventBus.on('shape.move.start', LOW_PRIORITY$5, function(e) {
49100
   var context = e.context,
       shapes = context.shapes,
       attachers = getAttachers(shapes);
49104
   forEach$2(attachers, function(attacher) {
     movePreview.makeDraggable(context, attacher, true);
49107
     forEach$2(attacher.labels, function(label) {
       movePreview.makeDraggable(context, label, true);
     });
   });
 });
49113
 // add attach-ok marker to current host
 movePreview && eventBus.on('shape.move.start', function(event) {
   var context = event.context,
       shapes = context.shapes;
49118
   if (shapes.length !== 1) {
     return;
   }
49122
   var shape = shapes[0];
49124
   var host = shape.host;
49126
   if (host) {
     canvas.addMarker(host, MARKER_ATTACH$1);
49129
     eventBus.once([
       'shape.move.out',
       'shape.move.cleanup'
     ], function() {
       canvas.removeMarker(host, MARKER_ATTACH$1);
     });
   }
 });
49138
 // add all attachers to move closure
 this.preExecuted('elements.move', HIGH_PRIORITY$4, function(e) {
   var context = e.context,
       closure = context.closure,
       shapes = context.shapes,
       attachers = getAttachers(shapes);
49145
   forEach$2(attachers, function(attacher) {
     closure.add(attacher, closure.topLevel[attacher.host.id]);
   });
 });
49150
 // perform the attaching after shapes are done moving
 this.postExecuted('elements.move', function(e) {
49153
   var context = e.context,
       shapes = context.shapes,
       newHost = context.newHost,
       attachers;
49158
   // only single elements can be attached
   // multiply elements can be detached
   if (newHost && shapes.length !== 1) {
     return;
   }
49164
   if (newHost) {
     attachers = shapes;
   } else {
49168
     // find attachers moved without host
     attachers = filter(shapes, function(shape) {
       var host = shape.host;
49172
       return isAttacher(shape) && !includes$4(shapes, host);
     });
   }
49176
   forEach$2(attachers, function(attacher) {
     modeling.updateAttachment(attacher, newHost);
   });
 });
49181
 // ensure invalid attachment connections are removed
 this.postExecuted('elements.move', function(e) {
49184
   var shapes = e.context.shapes;
49186
   forEach$2(shapes, function(shape) {
49188
     forEach$2(shape.attachers, function(attacher) {
49190
       // remove invalid outgoing connections
       forEach$2(attacher.outgoing.slice(), function(connection) {
         var allowed = rules.allowed('connection.reconnect', {
           connection: connection,
           source: connection.source,
           target: connection.target
         });
49198
         if (!allowed) {
           modeling.removeConnection(connection);
         }
       });
49203
       // remove invalid incoming connections
       forEach$2(attacher.incoming.slice(), function(connection) {
         var allowed = rules.allowed('connection.reconnect', {
           connection: connection,
           source: connection.source,
           target: connection.target
         });
49211
         if (!allowed) {
           modeling.removeConnection(connection);
         }
       });
     });
   });
 });
49219
 this.postExecute('shape.create', function(e) {
   var context = e.context,
       shape = context.shape,
       host = context.host;
49224
   if (host) {
     modeling.updateAttachment(shape, host);
   }
 });
49229
 // update attachments if the host is replaced
 this.postExecute('shape.replace', function(e) {
49232
   var context = e.context,
       oldShape = context.oldShape,
       newShape = context.newShape;
49236
   // move the attachers to the new host
   saveClear(oldShape.attachers, function(attacher) {
     var allowed = rules.allowed('elements.move', {
       target: newShape,
       shapes: [ attacher ]
     });
49243
     if (allowed === 'attach') {
       modeling.updateAttachment(attacher, newShape);
     } else {
       modeling.removeShape(attacher);
     }
   });
49250
   // move attachers if new host has different size
   if (newShape.attachers.length) {
49253
     forEach$2(newShape.attachers, function(attacher) {
       var delta = getNewAttachShapeDelta(attacher, oldShape, newShape);
       modeling.moveShape(attacher, delta, attacher.parent);
     });
   }
49259
 });
49261
 // move shape on host resize
 this.postExecute('shape.resize', function(event) {
   var context = event.context,
       shape = context.shape,
       oldBounds = context.oldBounds,
       newBounds = context.newBounds,
       attachers = shape.attachers,
       hints = context.hints || {};
49270
   if (hints.attachSupport === false) {
     return;
   }
49274
   forEach$2(attachers, function(attacher) {
     var delta = getNewAttachShapeDelta(attacher, oldBounds, newBounds);
49277
     modeling.moveShape(attacher, delta, attacher.parent);
49279
     forEach$2(attacher.labels, function(label) {
       modeling.moveShape(label, delta, label.parent);
     });
   });
 });
49285
 // remove attachments
 this.preExecute('shape.delete', function(event) {
49288
   var shape = event.context.shape;
49290
   saveClear(shape.attachers, function(attacher) {
     modeling.removeShape(attacher);
   });
49294
   if (shape.host) {
     modeling.updateAttachment(shape, null);
   }
 });
}
49300
inherits$1(AttachSupport, CommandInterceptor);
49302
AttachSupport.$inject = [
 'injector',
 'eventBus',
 'canvas',
 'rules',
 'modeling'
];
49310
49311
/**
* Return attachers of the given shapes
*
* @param {Array<djs.model.Base>} shapes
* @return {Array<djs.model.Base>}
*/
function getAttachers(shapes) {
 return flatten(map(shapes, function(s) {
   return s.attachers || [];
 }));
}
49323
/**
* Return a combined list of elements and
* attachers.
*
* @param {Array<djs.model.Base>} elements
* @return {Array<djs.model.Base>} filtered
*/
function addAttached(elements) {
 var attachers = getAttachers(elements);
49333
 return unionBy('id', elements, attachers);
}
49336
/**
* Return a filtered list of elements that do not
* contain attached elements with hosts being part
* of the selection.
*
* @param  {Array<djs.model.Base>} elements
*
* @return {Array<djs.model.Base>} filtered
*/
function removeAttached(elements) {
49347
 var ids = groupBy(elements, 'id');
49349
 return filter(elements, function(element) {
   while (element) {
49352
     // host in selection
     if (element.host && ids[element.host.id]) {
       return false;
     }
49357
     element = element.parent;
   }
49360
   return true;
 });
}
49364
function isAttacher(shape) {
 return !!shape.host;
}
49368
function includes$4(array, item) {
 return array.indexOf(item) !== -1;
}
49372
var AttachSupportModule = {
 __depends__: [
   RulesModule$1
 ],
 __init__: [ 'attachSupport' ],
 attachSupport: [ 'type', AttachSupport ]
};
49380
var LOW_PRIORITY$4 = 250;
49382
/**
* The tool manager acts as middle-man between the available tool's and the Palette,
* it takes care of making sure that the correct active state is set.
*
* @param  {Object}    eventBus
* @param  {Object}    dragging
*/
function ToolManager(eventBus, dragging) {
 this._eventBus = eventBus;
 this._dragging = dragging;
49393
 this._tools = [];
 this._active = null;
}
49397
ToolManager.$inject = [ 'eventBus', 'dragging' ];
49399
ToolManager.prototype.registerTool = function(name, events) {
 var tools = this._tools;
49402
 if (!events) {
   throw new Error('A tool has to be registered with it\'s "events"');
 }
49406
 tools.push(name);
49408
 this.bindEvents(name, events);
};
49411
ToolManager.prototype.isActive = function(tool) {
 return tool && this._active === tool;
};
49415
ToolManager.prototype.length = function(tool) {
 return this._tools.length;
};
49419
ToolManager.prototype.setActive = function(tool) {
 var eventBus = this._eventBus;
49422
 if (this._active !== tool) {
   this._active = tool;
49425
   eventBus.fire('tool-manager.update', { tool: tool });
 }
};
49429
ToolManager.prototype.bindEvents = function(name, events) {
 var eventBus = this._eventBus,
     dragging = this._dragging;
49433
 var eventsToRegister = [];
49435
 eventBus.on(events.tool + '.init', function(event) {
   var context = event.context;
49438
   // Active tools that want to reactivate themselves must do this explicitly
   if (!context.reactivate && this.isActive(name)) {
     this.setActive(null);
49442
     dragging.cancel();
     return;
   }
49446
   this.setActive(name);
49448
 }, this);
49450
 // Todo[ricardo]: add test cases
 forEach$2(events, function(event) {
   eventsToRegister.push(event + '.ended');
   eventsToRegister.push(event + '.canceled');
 });
49456
 eventBus.on(eventsToRegister, LOW_PRIORITY$4, function(event) {
49458
   // We defer the de-activation of the tool to the .activate phase,
   // so we're able to check if we want to toggle off the current
   // active tool or switch to a new one
   if (!this._active) {
     return;
   }
49465
   if (isPaletteClick(event)) {
     return;
   }
49469
   this.setActive(null);
 }, this);
49472
};
49474
49475
// helpers ///////////////
49477
/**
* Check if a given event is a palette click event.
*
* @param {EventBus.Event} event
*
* @return {boolean}
*/
function isPaletteClick(event) {
 var target = event.originalEvent && event.originalEvent.target;
49487
 return target && closest(target, '.group[data-group="tools"]');
}
49490
var ToolManagerModule = {
 __depends__: [
   DraggingModule
 ],
 __init__: [ 'toolManager' ],
 toolManager: [ 'type', ToolManager ]
};
49498
/**
* Return direction given axis and delta.
*
* @param {string} axis
* @param {number} delta
*
* @return {string}
*/
function getDirection(axis, delta) {
49508
 if (axis === 'x') {
   if (delta > 0) {
     return 'e';
   }
49513
   if (delta < 0) {
     return 'w';
   }
 }
49518
 if (axis === 'y') {
   if (delta > 0) {
     return 's';
   }
49523
   if (delta < 0) {
     return 'n';
   }
 }
49528
 return null;
}
49531
/**
* Returns connections whose waypoints are to be updated. Waypoints are to be updated if start
* or end is to be moved or resized.
*
* @param {Array<djs.model.Shape} movingShapes
* @param {Array<djs.model.Shape} resizingShapes
*
* @returns {Array<djs.model.Connection>}
*/
function getWaypointsUpdatingConnections(movingShapes, resizingShapes) {
 var waypointsUpdatingConnections = [];
49543
 forEach$2(movingShapes.concat(resizingShapes), function(shape) {
   var incoming = shape.incoming,
       outgoing = shape.outgoing;
49547
   forEach$2(incoming.concat(outgoing), function(connection) {
     var source = connection.source,
         target = connection.target;
49551
     if (includes$3(movingShapes, source) ||
       includes$3(movingShapes, target) ||
       includes$3(resizingShapes, source) ||
       includes$3(resizingShapes, target)) {
49556
       if (!includes$3(waypointsUpdatingConnections, connection)) {
         waypointsUpdatingConnections.push(connection);
       }
     }
   });
 });
49563
 return waypointsUpdatingConnections;
}
49566
function includes$3(array, item) {
 return array.indexOf(item) !== -1;
}
49570
/**
* Resize bounds.
*
* @param {Object} bounds
* @param {number} bounds.x
* @param {number} bounds.y
* @param {number} bounds.width
* @param {number} bounds.height
* @param {string} direction
* @param {Object} delta
* @param {number} delta.x
* @param {number} delta.y
*
* @return {Object}
*/
function resizeBounds(bounds, direction, delta) {
 var x = bounds.x,
     y = bounds.y,
     width = bounds.width,
     height = bounds.height,
     dx = delta.x,
     dy = delta.y;
49593
 switch (direction) {
 case 'n':
   return {
     x: x,
     y: y + dy,
     width: width,
     height: height - dy
   };
 case 's':
   return {
     x: x,
     y: y,
     width: width,
     height: height + dy
   };
 case 'w':
   return {
     x: x + dx,
     y: y,
     width: width - dx,
     height: height
   };
 case 'e':
   return {
     x: x,
     y: y,
     width: width + dx,
     height: height
   };
 default:
   throw new Error('unknown direction: ' + direction);
 }
}
49627
var abs$1 = Math.abs,
   round$4 = Math.round;
49630
var AXIS_TO_DIMENSION = {
 x: 'width',
 y: 'height'
};
49635
var CURSOR_CROSSHAIR = 'crosshair';
49637
var DIRECTION_TO_TRBL = {
 n: 'top',
 w: 'left',
 s: 'bottom',
 e: 'right'
};
49644
var HIGH_PRIORITY$3 = 1500;
49646
var DIRECTION_TO_OPPOSITE = {
 n: 's',
 w: 'e',
 s: 'n',
 e: 'w'
};
49653
var PADDING = 20;
49655
49656
/**
* Add or remove space by moving and resizing elements.
*
* @param {Canvas} canvas
* @param {Dragging} dragging
* @param {EventBus} eventBus
* @param {Modeling} modeling
* @param {Rules} rules
* @param {ToolManager} toolManager
* @param {Mouse} mouse
*/
function SpaceTool(
   canvas, dragging, eventBus,
   modeling, rules, toolManager,
   mouse) {
49672
 this._canvas = canvas;
 this._dragging = dragging;
 this._eventBus = eventBus;
 this._modeling = modeling;
 this._rules = rules;
 this._toolManager = toolManager;
 this._mouse = mouse;
49680
 var self = this;
49682
 toolManager.registerTool('space', {
   tool: 'spaceTool.selection',
   dragging: 'spaceTool'
 });
49687
 eventBus.on('spaceTool.selection.end', function(event) {
   eventBus.once('spaceTool.selection.ended', function() {
     self.activateMakeSpace(event.originalEvent);
   });
 });
49693
 eventBus.on('spaceTool.move', HIGH_PRIORITY$3 , function(event) {
   var context = event.context,
       initialized = context.initialized;
49697
   if (!initialized) {
     initialized = context.initialized = self.init(event, context);
   }
49701
   if (initialized) {
     ensureConstraints(event);
   }
 });
49706
 eventBus.on('spaceTool.end', function(event) {
   var context = event.context,
       axis = context.axis,
       direction = context.direction,
       movingShapes = context.movingShapes,
       resizingShapes = context.resizingShapes,
       start = context.start;
49714
   if (!context.initialized) {
     return;
   }
49718
   ensureConstraints(event);
49720
   var delta = {
     x: 0,
     y: 0
   };
49725
   delta[ axis ] = round$4(event[ 'd' + axis ]);
49727
   self.makeSpace(movingShapes, resizingShapes, delta, direction, start);
49729
   eventBus.once('spaceTool.ended', function(event) {
49731
     // activate space tool selection after make space
     self.activateSelection(event.originalEvent, true, true);
   });
 });
}
49737
SpaceTool.$inject = [
 'canvas',
 'dragging',
 'eventBus',
 'modeling',
 'rules',
 'toolManager',
 'mouse'
];
49747
/**
* Activate space tool selection.
*
* @param {Object} event
* @param {boolean} autoActivate
*/
SpaceTool.prototype.activateSelection = function(event, autoActivate, reactivate) {
 this._dragging.init(event, 'spaceTool.selection', {
   autoActivate: autoActivate,
   cursor: CURSOR_CROSSHAIR,
   data: {
     context: {
       reactivate: reactivate
     }
   },
   trapClick: false
 });
};
49766
/**
* Activate space tool make space.
*
* @param  {MouseEvent} event
*/
SpaceTool.prototype.activateMakeSpace = function(event) {
 this._dragging.init(event, 'spaceTool', {
   autoActivate: true,
   cursor: CURSOR_CROSSHAIR,
   data: {
     context: {}
   }
 });
};
49781
/**
* Make space.
*
* @param  {Array<djs.model.Shape>} movingShapes
* @param  {Array<djs.model.Shape>} resizingShapes
* @param  {Object} delta
* @param  {number} delta.x
* @param  {number} delta.y
* @param  {string} direction
* @param  {number} start
*/
SpaceTool.prototype.makeSpace = function(movingShapes, resizingShapes, delta, direction, start) {
 return this._modeling.createSpace(movingShapes, resizingShapes, delta, direction, start);
};
49796
/**
* Initialize make space and return true if that was successful.
*
* @param {Object} event
* @param {Object} context
*
* @return {boolean}
*/
SpaceTool.prototype.init = function(event, context) {
 var axis = abs$1(event.dx) > abs$1(event.dy) ? 'x' : 'y',
     delta = event[ 'd' + axis ],
     start = event[ axis ] - delta;
49809
 if (abs$1(delta) < 5) {
   return false;
 }
49813
 // invert delta to remove space when moving left
 if (delta < 0) {
   delta *= -1;
 }
49818
 // invert delta to add/remove space when removing/adding space if modifier key is pressed
 if (hasPrimaryModifier(event)) {
   delta *= -1;
 }
49823
 var direction = getDirection(axis, delta);
49825
 var root = this._canvas.getRootElement();
49827
 var children = selfAndAllChildren(root, true);
49829
 var elements = this.calculateAdjustments(children, axis, delta, start);
49831
 var minDimensions = this._eventBus.fire('spaceTool.getMinDimensions', {
   axis: axis,
   direction: direction,
   shapes: elements.resizingShapes,
   start: start
 });
49838
 var spaceToolConstraints = getSpaceToolConstraints(elements, axis, direction, start, minDimensions);
49840
 assign(
   context,
   elements,
   {
     axis: axis,
     direction: direction,
     spaceToolConstraints: spaceToolConstraints,
     start: start
   }
 );
49851
 set('resize-' + (axis === 'x' ? 'ew' : 'ns'));
49853
 return true;
};
49856
/**
* Get elements to be moved and resized.
*
* @param  {Array<djs.model.Shape>} elements
* @param  {string} axis
* @param  {number} delta
* @param  {number} start
*
* @return {Object}
*/
SpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, start) {
 var rules = this._rules;
49869
 var movingShapes = [],
     resizingShapes = [];
49872
 forEach$2(elements, function(element) {
   if (!element.parent || isConnection$7(element)) {
     return;
   }
49877
   var shapeStart = element[ axis ],
       shapeEnd = shapeStart + element[ AXIS_TO_DIMENSION[ axis ] ];
49880
   // shape to be moved
   if ((delta > 0 && shapeStart > start) || (delta < 0 && shapeEnd < start)) {
     return movingShapes.push(element);
   }
49885
   // shape to be resized
   if (shapeStart < start &&
     shapeEnd > start &&
     rules.allowed('shape.resize', { shape: element })
   ) {
49891
     return resizingShapes.push(element);
   }
 });
49895
 return {
   movingShapes: movingShapes,
   resizingShapes: resizingShapes
 };
};
49901
SpaceTool.prototype.toggle = function() {
49903
 if (this.isActive()) {
   return this._dragging.cancel();
 }
49907
 var mouseEvent = this._mouse.getLastMoveEvent();
49909
 this.activateSelection(mouseEvent, !!mouseEvent);
};
49912
SpaceTool.prototype.isActive = function() {
 var context = this._dragging.context();
49915
 return context && /^spaceTool/.test(context.prefix);
};
49918
// helpers //////////
49920
function addPadding(trbl) {
 return {
   top: trbl.top - PADDING,
   right: trbl.right + PADDING,
   bottom: trbl.bottom + PADDING,
   left: trbl.left - PADDING
 };
}
49929
function ensureConstraints(event) {
 var context = event.context,
     spaceToolConstraints = context.spaceToolConstraints;
49933
 if (!spaceToolConstraints) {
   return;
 }
49937
 var x, y;
49939
 if (isNumber(spaceToolConstraints.left)) {
   x = Math.max(event.x, spaceToolConstraints.left);
49942
   event.dx = event.dx + x - event.x;
   event.x = x;
 }
49946
 if (isNumber(spaceToolConstraints.right)) {
   x = Math.min(event.x, spaceToolConstraints.right);
49949
   event.dx = event.dx + x - event.x;
   event.x = x;
 }
49953
 if (isNumber(spaceToolConstraints.top)) {
   y = Math.max(event.y, spaceToolConstraints.top);
49956
   event.dy = event.dy + y - event.y;
   event.y = y;
 }
49960
 if (isNumber(spaceToolConstraints.bottom)) {
   y = Math.min(event.y, spaceToolConstraints.bottom);
49963
   event.dy = event.dy + y - event.y;
   event.y = y;
 }
}
49968
function getSpaceToolConstraints(elements, axis, direction, start, minDimensions) {
 var movingShapes = elements.movingShapes,
     resizingShapes = elements.resizingShapes;
49972
 if (!resizingShapes.length) {
   return;
 }
49976
 var spaceToolConstraints = {},
     min,
     max;
49980
 forEach$2(resizingShapes, function(resizingShape) {
   var resizingShapeBBox = asTRBL(resizingShape);
49983
   // find children that are not moving or resizing
   var nonMovingResizingChildren = filter(resizingShape.children, function(child) {
     return !isConnection$7(child) &&
       !isLabel$2(child) &&
       !includes$2(movingShapes, child) &&
       !includes$2(resizingShapes, child);
   });
49991
   // find children that are moving
   var movingChildren = filter(resizingShape.children, function(child) {
     return !isConnection$7(child) && !isLabel$2(child) && includes$2(movingShapes, child);
   });
49996
   var minOrMax,
       nonMovingResizingChildrenBBox,
       movingChildrenBBox;
50000
   if (nonMovingResizingChildren.length) {
     nonMovingResizingChildrenBBox = addPadding(asTRBL(getBBox(nonMovingResizingChildren)));
50003
     minOrMax = start -
       resizingShapeBBox[ DIRECTION_TO_TRBL[ direction ] ] +
       nonMovingResizingChildrenBBox[ DIRECTION_TO_TRBL[ direction ] ];
50007
     if (direction === 'n') {
       spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
     } else if (direction === 'w') {
       spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
     } else if (direction === 's') {
       spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
     } else if (direction === 'e') {
       spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
     }
   }
50018
   if (movingChildren.length) {
     movingChildrenBBox = addPadding(asTRBL(getBBox(movingChildren)));
50021
     minOrMax = start -
       movingChildrenBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ] +
       resizingShapeBBox[ DIRECTION_TO_TRBL[ DIRECTION_TO_OPPOSITE[ direction ] ] ];
50025
     if (direction === 'n') {
       spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
     } else if (direction === 'w') {
       spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
     } else if (direction === 's') {
       spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
     } else if (direction === 'e') {
       spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
     }
   }
50036
   var resizingShapeMinDimensions = minDimensions && minDimensions[ resizingShape.id ];
50038
   if (resizingShapeMinDimensions) {
     if (direction === 'n') {
       minOrMax = start +
         resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
         resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
50044
       spaceToolConstraints.bottom = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
     } else if (direction === 'w') {
       minOrMax = start +
         resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
         resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
50050
       spaceToolConstraints.right = max = isNumber(max) ? Math.min(max, minOrMax) : minOrMax;
     } else if (direction === 's') {
       minOrMax = start -
         resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
         resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
50056
       spaceToolConstraints.top = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
     } else if (direction === 'e') {
       minOrMax = start -
         resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
         resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
50062
       spaceToolConstraints.left = min = isNumber(min) ? Math.max(min, minOrMax) : minOrMax;
     }
   }
 });
50067
 return spaceToolConstraints;
}
50070
function includes$2(array, item) {
 return array.indexOf(item) !== -1;
}
50074
function isConnection$7(element) {
 return !!element.waypoints;
}
50078
function isLabel$2(element) {
 return !!element.labelTarget;
}
50082
var MARKER_DRAGGING$1 = 'djs-dragging',
   MARKER_RESIZING = 'djs-resizing';
50085
var LOW_PRIORITY$3 = 250;
50087
var max = Math.max;
50089
50090
/**
* Provides previews for selecting/moving/resizing shapes when creating/removing space.
*
* @param {EventBus} eventBus
* @param {ElementRegistry} elementRegistry
* @param {Canvas} canvas
* @param {Styles} styles
*/
function SpaceToolPreview(
   eventBus, elementRegistry, canvas,
   styles, previewSupport) {
50102
 function addPreviewGfx(collection, dragGroup) {
   forEach$2(collection, function(element) {
     previewSupport.addDragger(element, dragGroup);
50106
     canvas.addMarker(element, MARKER_DRAGGING$1);
   });
 }
50110
 // add crosshair
 eventBus.on('spaceTool.selection.start', function(event) {
   var space = canvas.getLayer('space'),
       context = event.context;
50115
   var orientation = {
     x: 'M 0,-10000 L 0,10000',
     y: 'M -10000,0 L 10000,0'
   };
50120
   var crosshairGroup = create$1('g');
   attr$1(crosshairGroup, styles.cls('djs-crosshair-group', [ 'no-events' ]));
50123
   append(space, crosshairGroup);
50125
   // horizontal path
   var pathX = create$1('path');
   attr$1(pathX, 'd', orientation.x);
   classes$1(pathX).add('djs-crosshair');
50130
   append(crosshairGroup, pathX);
50132
   // vertical path
   var pathY = create$1('path');
   attr$1(pathY, 'd', orientation.y);
   classes$1(pathY).add('djs-crosshair');
50137
   append(crosshairGroup, pathY);
50139
   context.crosshairGroup = crosshairGroup;
 });
50142
 // update crosshair
 eventBus.on('spaceTool.selection.move', function(event) {
   var crosshairGroup = event.context.crosshairGroup;
50146
   translate$2(crosshairGroup, event.x, event.y);
 });
50149
 // remove crosshair
 eventBus.on('spaceTool.selection.cleanup', function(event) {
   var context = event.context,
       crosshairGroup = context.crosshairGroup;
50154
   if (crosshairGroup) {
     remove$2(crosshairGroup);
   }
 });
50159
 // add and update move/resize previews
 eventBus.on('spaceTool.move', LOW_PRIORITY$3, function(event) {
50162
   var context = event.context,
       line = context.line,
       axis = context.axis,
       movingShapes = context.movingShapes,
       resizingShapes = context.resizingShapes;
50168
   if (!context.initialized) {
     return;
   }
50172
   if (!context.dragGroup) {
     var spaceLayer = canvas.getLayer('space');
50175
     line = create$1('path');
     attr$1(line, 'd', 'M0,0 L0,0');
     classes$1(line).add('djs-crosshair');
50179
     append(spaceLayer, line);
50181
     context.line = line;
50183
     var dragGroup = create$1('g');
     attr$1(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));
50186
     append(canvas.getActiveLayer(), dragGroup);
50188
     // shapes
     addPreviewGfx(movingShapes, dragGroup);
50191
     // connections
     var movingConnections = context.movingConnections = elementRegistry.filter(function(element) {
       var sourceIsMoving = false;
50195
       forEach$2(movingShapes, function(shape) {
         forEach$2(shape.outgoing, function(connection) {
           if (element === connection) {
             sourceIsMoving = true;
           }
         });
       });
50203
       var targetIsMoving = false;
50205
       forEach$2(movingShapes, function(shape) {
         forEach$2(shape.incoming, function(connection) {
           if (element === connection) {
             targetIsMoving = true;
           }
         });
       });
50213
       var sourceIsResizing = false;
50215
       forEach$2(resizingShapes, function(shape) {
         forEach$2(shape.outgoing, function(connection) {
           if (element === connection) {
             sourceIsResizing = true;
           }
         });
       });
50223
       var targetIsResizing = false;
50225
       forEach$2(resizingShapes, function(shape) {
         forEach$2(shape.incoming, function(connection) {
           if (element === connection) {
             targetIsResizing = true;
           }
         });
       });
50233
       return isConnection$6(element)
         && (sourceIsMoving || sourceIsResizing)
         && (targetIsMoving || targetIsResizing);
     });
50238
50239
     addPreviewGfx(movingConnections, dragGroup);
50241
     context.dragGroup = dragGroup;
   }
50244
   if (!context.frameGroup) {
     var frameGroup = create$1('g');
     attr$1(frameGroup, styles.cls('djs-frame-group', [ 'no-events' ]));
50248
     append(canvas.getActiveLayer(), frameGroup);
50250
     var frames = [];
50252
     forEach$2(resizingShapes, function(shape) {
       var frame = previewSupport.addFrame(shape, frameGroup);
50255
       var initialBounds = frame.getBBox();
50257
       frames.push({
         element: frame,
         initialBounds: initialBounds
       });
50262
       canvas.addMarker(shape, MARKER_RESIZING);
     });
50265
     context.frameGroup = frameGroup;
     context.frames = frames;
   }
50269
   var orientation = {
     x: 'M' + event.x + ', -10000 L' + event.x + ', 10000',
     y: 'M -10000, ' + event.y + ' L 10000, ' + event.y
   };
50274
   attr$1(line, { d: orientation[ axis ] });
50276
   var opposite = { x: 'y', y: 'x' };
   var delta = { x: event.dx, y: event.dy };
   delta[ opposite[ context.axis ] ] = 0;
50280
   // update move previews
   translate$2(context.dragGroup, delta.x, delta.y);
50283
   // update resize previews
   forEach$2(context.frames, function(frame) {
     var element = frame.element,
         initialBounds = frame.initialBounds,
         width,
         height;
50290
     if (context.direction === 'e') {
       attr$1(element, {
         width: max(initialBounds.width + delta.x, 5)
       });
     } else {
       width = max(initialBounds.width - delta.x, 5);
50297
       attr$1(element, {
         width: width,
         x: initialBounds.x + initialBounds.width - width
       });
     }
50303
     if (context.direction === 's') {
       attr$1(element, {
         height: max(initialBounds.height + delta.y, 5)
       });
     } else {
       height = max(initialBounds.height - delta.y, 5);
50310
       attr$1(element, {
         height: height,
         y: initialBounds.y + initialBounds.height - height
       });
     }
   });
50317
 });
50319
 // remove move/resize previews
 eventBus.on('spaceTool.cleanup', function(event) {
50322
   var context = event.context,
       movingShapes = context.movingShapes,
       movingConnections = context.movingConnections,
       resizingShapes = context.resizingShapes,
       line = context.line,
       dragGroup = context.dragGroup,
       frameGroup = context.frameGroup;
50330
   // moving shapes
   forEach$2(movingShapes, function(shape) {
     canvas.removeMarker(shape, MARKER_DRAGGING$1);
   });
50335
   // moving connections
   forEach$2(movingConnections, function(connection) {
     canvas.removeMarker(connection, MARKER_DRAGGING$1);
   });
50340
   if (dragGroup) {
     remove$2(line);
     remove$2(dragGroup);
   }
50345
   forEach$2(resizingShapes, function(shape) {
     canvas.removeMarker(shape, MARKER_RESIZING);
   });
50349
   if (frameGroup) {
     remove$2(frameGroup);
   }
 });
}
50355
SpaceToolPreview.$inject = [
 'eventBus',
 'elementRegistry',
 'canvas',
 'styles',
 'previewSupport'
];
50363
50364
// helpers //////////////////////
50366
/**
* Checks if an element is a connection.
*/
function isConnection$6(element) {
 return element.waypoints;
}
50373
var SpaceToolModule = {
 __init__: [ 'spaceToolPreview' ],
 __depends__: [
   DraggingModule,
   RulesModule$1,
   ToolManagerModule,
   PreviewSupportModule,
   MouseModule
 ],
 spaceTool: [ 'type', SpaceTool ],
 spaceToolPreview: [ 'type', SpaceToolPreview ]
};
50386
function BpmnFactory(moddle) {
 this._model = moddle;
}
50390
BpmnFactory.$inject = [ 'moddle' ];
50392
50393
BpmnFactory.prototype._needsId = function(element) {
 return isAny(element, [
   'bpmn:RootElement',
   'bpmn:FlowElement',
   'bpmn:MessageFlow',
   'bpmn:DataAssociation',
   'bpmn:Artifact',
   'bpmn:Participant',
   'bpmn:Lane',
   'bpmn:LaneSet',
   'bpmn:Process',
   'bpmn:Collaboration',
   'bpmndi:BPMNShape',
   'bpmndi:BPMNEdge',
   'bpmndi:BPMNDiagram',
   'bpmndi:BPMNPlane',
   'bpmn:Property',
   'bpmn:CategoryValue'
 ]);
};
50414
BpmnFactory.prototype._ensureId = function(element) {
 if (element.id) {
   this._model.ids.claim(element.id, element);
   return;
 }
50420
 // generate semantic ids for elements
 // bpmn:SequenceFlow -> SequenceFlow_ID
 var prefix;
50424
 if (is$1(element, 'bpmn:Activity')) {
   prefix = 'Activity';
 } else if (is$1(element, 'bpmn:Event')) {
   prefix = 'Event';
 } else if (is$1(element, 'bpmn:Gateway')) {
   prefix = 'Gateway';
 } else if (isAny(element, [ 'bpmn:SequenceFlow', 'bpmn:MessageFlow' ])) {
   prefix = 'Flow';
 } else {
   prefix = (element.$type || '').replace(/^[^:]*:/g, '');
 }
50436
 prefix += '_';
50438
 if (!element.id && this._needsId(element)) {
   element.id = this._model.ids.nextPrefixed(prefix, element);
 }
};
50443
50444
BpmnFactory.prototype.create = function(type, attrs) {
 var element = this._model.create(type, attrs || {});
50447
 this._ensureId(element);
50449
 return element;
};
50452
50453
BpmnFactory.prototype.createDiLabel = function() {
 return this.create('bpmndi:BPMNLabel', {
   bounds: this.createDiBounds()
 });
};
50459
50460
BpmnFactory.prototype.createDiShape = function(semantic, attrs) {
 return this.create('bpmndi:BPMNShape', assign({
   bpmnElement: semantic,
   bounds: this.createDiBounds()
 }, attrs));
};
50467
50468
BpmnFactory.prototype.createDiBounds = function(bounds) {
 return this.create('dc:Bounds', bounds);
};
50472
50473
BpmnFactory.prototype.createDiWaypoints = function(waypoints) {
 var self = this;
50476
 return map(waypoints, function(pos) {
   return self.createDiWaypoint(pos);
 });
};
50481
BpmnFactory.prototype.createDiWaypoint = function(point) {
 return this.create('dc:Point', pick(point, [ 'x', 'y' ]));
};
50485
50486
BpmnFactory.prototype.createDiEdge = function(semantic, attrs) {
 return this.create('bpmndi:BPMNEdge', assign({
   bpmnElement: semantic,
   waypoint: this.createDiWaypoints([])
 }, attrs));
};
50493
BpmnFactory.prototype.createDiPlane = function(semantic, attrs) {
 return this.create('bpmndi:BPMNPlane', assign({
   bpmnElement: semantic
 }, attrs));
};
50499
/**
* A handler responsible for updating the underlying BPMN 2.0 XML + DI
* once changes on the diagram happen
*/
function BpmnUpdater(
   eventBus, bpmnFactory, connectionDocking,
   translate) {
50507
 CommandInterceptor.call(this, eventBus);
50509
 this._bpmnFactory = bpmnFactory;
 this._translate = translate;
50512
 var self = this;
50514
50515
50516
 // connection cropping //////////////////////
50518
 // crop connection ends during create/update
 function cropConnection(e) {
   var context = e.context,
       hints = context.hints || {},
       connection;
50524
   if (!context.cropped && hints.createElementsBehavior !== false) {
     connection = context.connection;
     connection.waypoints = connectionDocking.getCroppedWaypoints(connection);
     context.cropped = true;
   }
 }
50531
 this.executed([
   'connection.layout',
   'connection.create'
 ], cropConnection);
50536
 this.reverted([ 'connection.layout' ], function(e) {
   delete e.context.cropped;
 });
50540
50541
50542
 // BPMN + DI update //////////////////////
50544
50545
 // update parent
 function updateParent(e) {
   var context = e.context;
50549
   self.updateParent(context.shape || context.connection, context.oldParent);
 }
50552
 function reverseUpdateParent(e) {
   var context = e.context;
50555
   var element = context.shape || context.connection,
50557
       // oldParent is the (old) new parent, because we are undoing
       oldParent = context.parent || context.newParent;
50560
   self.updateParent(element, oldParent);
 }
50563
 this.executed([
   'shape.move',
   'shape.create',
   'shape.delete',
   'connection.create',
   'connection.move',
   'connection.delete'
 ], ifBpmn(updateParent));
50572
 this.reverted([
   'shape.move',
   'shape.create',
   'shape.delete',
   'connection.create',
   'connection.move',
   'connection.delete'
 ], ifBpmn(reverseUpdateParent));
50581
 /*
  * ## Updating Parent
  *
  * When morphing a Process into a Collaboration or vice-versa,
  * make sure that both the *semantic* and *di* parent of each element
  * is updated.
  *
  */
 function updateRoot(event) {
   var context = event.context,
       oldRoot = context.oldRoot,
       children = oldRoot.children;
50594
   forEach$2(children, function(child) {
     if (is$1(child, 'bpmn:BaseElement')) {
       self.updateParent(child);
     }
   });
 }
50601
 this.executed([ 'canvas.updateRoot' ], updateRoot);
 this.reverted([ 'canvas.updateRoot' ], updateRoot);
50604
50605
 // update bounds
 function updateBounds(e) {
   var shape = e.context.shape;
50609
   if (!is$1(shape, 'bpmn:BaseElement')) {
     return;
   }
50613
   self.updateBounds(shape);
 }
50616
 this.executed([ 'shape.move', 'shape.create', 'shape.resize' ], ifBpmn(function(event) {
50618
   // exclude labels because they're handled separately during shape.changed
   if (event.context.shape.type === 'label') {
     return;
   }
50623
   updateBounds(event);
 }));
50626
 this.reverted([ 'shape.move', 'shape.create', 'shape.resize' ], ifBpmn(function(event) {
50628
   // exclude labels because they're handled separately during shape.changed
   if (event.context.shape.type === 'label') {
     return;
   }
50633
   updateBounds(event);
 }));
50636
 // Handle labels separately. This is necessary, because the label bounds have to be updated
 // every time its shape changes, not only on move, create and resize.
 eventBus.on('shape.changed', function(event) {
   if (event.element.type === 'label') {
     updateBounds({ context: { shape: event.element } });
   }
 });
50644
 // attach / detach connection
 function updateConnection(e) {
   self.updateConnection(e.context);
 }
50649
 this.executed([
   'connection.create',
   'connection.move',
   'connection.delete',
   'connection.reconnect'
 ], ifBpmn(updateConnection));
50656
 this.reverted([
   'connection.create',
   'connection.move',
   'connection.delete',
   'connection.reconnect'
 ], ifBpmn(updateConnection));
50663
50664
 // update waypoints
 function updateConnectionWaypoints(e) {
   self.updateConnectionWaypoints(e.context.connection);
 }
50669
 this.executed([
   'connection.layout',
   'connection.move',
   'connection.updateWaypoints',
 ], ifBpmn(updateConnectionWaypoints));
50675
 this.reverted([
   'connection.layout',
   'connection.move',
   'connection.updateWaypoints',
 ], ifBpmn(updateConnectionWaypoints));
50681
 // update conditional/default flows
 this.executed('connection.reconnect', ifBpmn(function(event) {
   var context = event.context,
       connection = context.connection,
       oldSource = context.oldSource,
       newSource = context.newSource,
       connectionBo = getBusinessObject(connection),
       oldSourceBo = getBusinessObject(oldSource),
       newSourceBo = getBusinessObject(newSource);
50691
   // remove condition from connection on reconnect to new source
   // if new source can NOT have condional sequence flow
   if (connectionBo.conditionExpression && !isAny(newSourceBo, [
     'bpmn:Activity',
     'bpmn:ExclusiveGateway',
     'bpmn:InclusiveGateway'
   ])) {
     context.oldConditionExpression = connectionBo.conditionExpression;
50700
     delete connectionBo.conditionExpression;
   }
50703
   // remove default from old source flow on reconnect to new source
   // if source changed
   if (oldSource !== newSource && oldSourceBo.default === connectionBo) {
     context.oldDefault = oldSourceBo.default;
50708
     delete oldSourceBo.default;
   }
 }));
50712
 this.reverted('connection.reconnect', ifBpmn(function(event) {
   var context = event.context,
       connection = context.connection,
       oldSource = context.oldSource,
       newSource = context.newSource,
       connectionBo = getBusinessObject(connection),
       oldSourceBo = getBusinessObject(oldSource),
       newSourceBo = getBusinessObject(newSource);
50721
   // add condition to connection on revert reconnect to new source
   if (context.oldConditionExpression) {
     connectionBo.conditionExpression = context.oldConditionExpression;
   }
50726
   // add default to old source on revert reconnect to new source
   if (context.oldDefault) {
     oldSourceBo.default = context.oldDefault;
50730
     delete newSourceBo.default;
   }
 }));
50734
 // update attachments
 function updateAttachment(e) {
   self.updateAttachment(e.context);
 }
50739
 this.executed([ 'element.updateAttachment' ], ifBpmn(updateAttachment));
 this.reverted([ 'element.updateAttachment' ], ifBpmn(updateAttachment));
}
50743
inherits$1(BpmnUpdater, CommandInterceptor);
50745
BpmnUpdater.$inject = [
 'eventBus',
 'bpmnFactory',
 'connectionDocking',
 'translate'
];
50752
50753
// implementation //////////////////////
50755
BpmnUpdater.prototype.updateAttachment = function(context) {
50757
 var shape = context.shape,
     businessObject = shape.businessObject,
     host = shape.host;
50761
 businessObject.attachedToRef = host && host.businessObject;
};
50764
BpmnUpdater.prototype.updateParent = function(element, oldParent) {
50766
 // do not update BPMN 2.0 label parent
 if (element instanceof Label) {
   return;
 }
50771
 // data stores in collaborations are handled separately by DataStoreBehavior
 if (is$1(element, 'bpmn:DataStoreReference') &&
     element.parent &&
     is$1(element.parent, 'bpmn:Collaboration')) {
   return;
 }
50778
 var parentShape = element.parent;
50780
 var businessObject = element.businessObject,
     di = getDi(element),
     parentBusinessObject = parentShape && parentShape.businessObject,
     parentDi = getDi(parentShape);
50785
 if (is$1(element, 'bpmn:FlowNode')) {
   this.updateFlowNodeRefs(businessObject, parentBusinessObject, oldParent && oldParent.businessObject);
 }
50789
 if (is$1(element, 'bpmn:DataOutputAssociation')) {
   if (element.source) {
     parentBusinessObject = element.source.businessObject;
   } else {
     parentBusinessObject = null;
   }
 }
50797
 if (is$1(element, 'bpmn:DataInputAssociation')) {
   if (element.target) {
     parentBusinessObject = element.target.businessObject;
   } else {
     parentBusinessObject = null;
   }
 }
50805
 this.updateSemanticParent(businessObject, parentBusinessObject);
50807
 if (is$1(element, 'bpmn:DataObjectReference') && businessObject.dataObjectRef) {
   this.updateSemanticParent(businessObject.dataObjectRef, parentBusinessObject);
 }
50811
 this.updateDiParent(di, parentDi);
};
50814
50815
BpmnUpdater.prototype.updateBounds = function(shape) {
50817
 var di = getDi(shape),
     embeddedLabelBounds = getEmbeddedLabelBounds(shape);
50820
 // update embedded label bounds if possible
 if (embeddedLabelBounds) {
   var embeddedLabelBoundsDelta = delta(embeddedLabelBounds, di.get('bounds'));
50824
   assign(embeddedLabelBounds, {
     x: shape.x + embeddedLabelBoundsDelta.x,
     y: shape.y + embeddedLabelBoundsDelta.y
   });
 }
50830
 var target = (shape instanceof Label) ? this._getLabel(di) : di;
50832
 var bounds = target.bounds;
50834
 if (!bounds) {
   bounds = this._bpmnFactory.createDiBounds();
   target.set('bounds', bounds);
 }
50839
 assign(bounds, {
   x: shape.x,
   y: shape.y,
   width: shape.width,
   height: shape.height
 });
};
50847
BpmnUpdater.prototype.updateFlowNodeRefs = function(businessObject, newContainment, oldContainment) {
50849
 if (oldContainment === newContainment) {
   return;
 }
50853
 var oldRefs, newRefs;
50855
 if (is$1 (oldContainment, 'bpmn:Lane')) {
   oldRefs = oldContainment.get('flowNodeRef');
   remove(oldRefs, businessObject);
 }
50860
 if (is$1(newContainment, 'bpmn:Lane')) {
   newRefs = newContainment.get('flowNodeRef');
   add(newRefs, businessObject);
 }
};
50866
50867
// update existing sourceElement and targetElement di information
BpmnUpdater.prototype.updateDiConnection = function(connection, newSource, newTarget) {
 var connectionDi = getDi(connection),
     newSourceDi = getDi(newSource),
     newTargetDi = getDi(newTarget);
50873
 if (connectionDi.sourceElement && connectionDi.sourceElement.bpmnElement !== getBusinessObject(newSource)) {
   connectionDi.sourceElement = newSource && newSourceDi;
 }
50877
 if (connectionDi.targetElement && connectionDi.targetElement.bpmnElement !== getBusinessObject(newTarget)) {
   connectionDi.targetElement = newTarget && newTargetDi;
 }
50881
};
50883
50884
BpmnUpdater.prototype.updateDiParent = function(di, parentDi) {
50886
 if (parentDi && !is$1(parentDi, 'bpmndi:BPMNPlane')) {
   parentDi = parentDi.$parent;
 }
50890
 if (di.$parent === parentDi) {
   return;
 }
50894
 var planeElements = (parentDi || di.$parent).get('planeElement');
50896
 if (parentDi) {
   planeElements.push(di);
   di.$parent = parentDi;
 } else {
   remove(planeElements, di);
   di.$parent = null;
 }
};
50905
function getDefinitions(element) {
 while (element && !is$1(element, 'bpmn:Definitions')) {
   element = element.$parent;
 }
50910
 return element;
}
50913
BpmnUpdater.prototype.getLaneSet = function(container) {
50915
 var laneSet, laneSets;
50917
 // bpmn:Lane
 if (is$1(container, 'bpmn:Lane')) {
   laneSet = container.childLaneSet;
50921
   if (!laneSet) {
     laneSet = this._bpmnFactory.create('bpmn:LaneSet');
     container.childLaneSet = laneSet;
     laneSet.$parent = container;
   }
50927
   return laneSet;
 }
50930
 // bpmn:Participant
 if (is$1(container, 'bpmn:Participant')) {
   container = container.processRef;
 }
50935
 // bpmn:FlowElementsContainer
 laneSets = container.get('laneSets');
 laneSet = laneSets[0];
50939
 if (!laneSet) {
   laneSet = this._bpmnFactory.create('bpmn:LaneSet');
   laneSet.$parent = container;
   laneSets.push(laneSet);
 }
50945
 return laneSet;
};
50948
BpmnUpdater.prototype.updateSemanticParent = function(businessObject, newParent, visualParent) {
50950
 var containment,
     translate = this._translate;
50953
 if (businessObject.$parent === newParent) {
   return;
 }
50957
 if (is$1(businessObject, 'bpmn:DataInput') || is$1(businessObject, 'bpmn:DataOutput')) {
50959
   if (is$1(newParent, 'bpmn:Participant') && 'processRef' in newParent) {
     newParent = newParent.processRef;
   }
50963
   // already in correct ioSpecification
   if ('ioSpecification' in newParent && newParent.ioSpecification === businessObject.$parent) {
     return;
   }
 }
50969
 if (is$1(businessObject, 'bpmn:Lane')) {
50971
   if (newParent) {
     newParent = this.getLaneSet(newParent);
   }
50975
   containment = 'lanes';
 } else
50978
 if (is$1(businessObject, 'bpmn:FlowElement')) {
50980
   if (newParent) {
50982
     if (is$1(newParent, 'bpmn:Participant')) {
       newParent = newParent.processRef;
     } else
50986
     if (is$1(newParent, 'bpmn:Lane')) {
       do {
50989
         // unwrap Lane -> LaneSet -> (Lane | FlowElementsContainer)
         newParent = newParent.$parent.$parent;
       } while (is$1(newParent, 'bpmn:Lane'));
50993
     }
   }
50996
   containment = 'flowElements';
50998
 } else
51000
 if (is$1(businessObject, 'bpmn:Artifact')) {
51002
   while (newParent &&
          !is$1(newParent, 'bpmn:Process') &&
          !is$1(newParent, 'bpmn:SubProcess') &&
          !is$1(newParent, 'bpmn:Collaboration')) {
51007
     if (is$1(newParent, 'bpmn:Participant')) {
       newParent = newParent.processRef;
       break;
     } else {
       newParent = newParent.$parent;
     }
   }
51015
   containment = 'artifacts';
 } else
51018
 if (is$1(businessObject, 'bpmn:MessageFlow')) {
   containment = 'messageFlows';
51021
 } else
51023
 if (is$1(businessObject, 'bpmn:Participant')) {
   containment = 'participants';
51026
   // make sure the participants process is properly attached / detached
   // from the XML document
51029
   var process = businessObject.processRef,
       definitions;
51032
   if (process) {
     definitions = getDefinitions(businessObject.$parent || newParent);
51035
     if (businessObject.$parent) {
       remove(definitions.get('rootElements'), process);
       process.$parent = null;
     }
51040
     if (newParent) {
       add(definitions.get('rootElements'), process);
       process.$parent = definitions;
     }
   }
 } else
51047
 if (is$1(businessObject, 'bpmn:DataOutputAssociation')) {
   containment = 'dataOutputAssociations';
 } else
51051
 if (is$1(businessObject, 'bpmn:DataInputAssociation')) {
   containment = 'dataInputAssociations';
 }
51055
 if (!containment) {
   throw new Error(translate(
     'no parent for {element} in {parent}',
     {
       element: businessObject.id,
       parent: newParent.id
     }
   ));
 }
51065
 var children;
51067
 if (businessObject.$parent) {
51069
   // remove from old parent
   children = businessObject.$parent.get(containment);
   remove(children, businessObject);
 }
51074
 if (!newParent) {
   businessObject.$parent = null;
 } else {
51078
   // add to new parent
   children = newParent.get(containment);
   children.push(businessObject);
   businessObject.$parent = newParent;
 }
51084
 if (visualParent) {
   var diChildren = visualParent.get(containment);
51087
   remove(children, businessObject);
51089
   if (newParent) {
51091
     if (!diChildren) {
       diChildren = [];
       newParent.set(containment, diChildren);
     }
51096
     diChildren.push(businessObject);
   }
 }
};
51101
51102
BpmnUpdater.prototype.updateConnectionWaypoints = function(connection) {
 var di = getDi(connection);
51105
 di.set('waypoint', this._bpmnFactory.createDiWaypoints(connection.waypoints));
};
51108
51109
BpmnUpdater.prototype.updateConnection = function(context) {
 var connection = context.connection,
     businessObject = getBusinessObject(connection),
     newSource = connection.source,
     newSourceBo = getBusinessObject(newSource),
     newTarget = connection.target,
     newTargetBo = getBusinessObject(connection.target),
     visualParent;
51118
 if (!is$1(businessObject, 'bpmn:DataAssociation')) {
51120
   var inverseSet = is$1(businessObject, 'bpmn:SequenceFlow');
51122
   if (businessObject.sourceRef !== newSourceBo) {
     if (inverseSet) {
       remove(businessObject.sourceRef && businessObject.sourceRef.get('outgoing'), businessObject);
51126
       if (newSourceBo && newSourceBo.get('outgoing')) {
         newSourceBo.get('outgoing').push(businessObject);
       }
     }
51131
     businessObject.sourceRef = newSourceBo;
   }
51134
   if (businessObject.targetRef !== newTargetBo) {
     if (inverseSet) {
       remove(businessObject.targetRef && businessObject.targetRef.get('incoming'), businessObject);
51138
       if (newTargetBo && newTargetBo.get('incoming')) {
         newTargetBo.get('incoming').push(businessObject);
       }
     }
51143
     businessObject.targetRef = newTargetBo;
   }
 } else
51147
 if (is$1(businessObject, 'bpmn:DataInputAssociation')) {
51149
   // handle obnoxious isMsome sourceRef
   businessObject.get('sourceRef')[0] = newSourceBo;
51152
   visualParent = context.parent || context.newParent || newTargetBo;
51154
   this.updateSemanticParent(businessObject, newTargetBo, visualParent);
 } else
51157
 if (is$1(businessObject, 'bpmn:DataOutputAssociation')) {
   visualParent = context.parent || context.newParent || newSourceBo;
51160
   this.updateSemanticParent(businessObject, newSourceBo, visualParent);
51162
   // targetRef = new target
   businessObject.targetRef = newTargetBo;
 }
51166
 this.updateConnectionWaypoints(connection);
51168
 this.updateDiConnection(connection, newSource, newTarget);
};
51171
51172
// helpers //////////////////////
51174
BpmnUpdater.prototype._getLabel = function(di) {
 if (!di.label) {
   di.label = this._bpmnFactory.createDiLabel();
 }
51179
 return di.label;
};
51182
51183
/**
* Make sure the event listener is only called
* if the touched element is a BPMN element.
*
* @param  {Function} fn
* @return {Function} guarded function
*/
function ifBpmn(fn) {
51192
 return function(event) {
51194
   var context = event.context,
       element = context.shape || context.connection;
51197
   if (is$1(element, 'bpmn:BaseElement')) {
     fn(event);
   }
 };
}
51203
/**
* Return dc:Bounds of bpmndi:BPMNLabel if exists.
*
* @param {djs.model.shape} shape
*
* @returns {Object|undefined}
*/
function getEmbeddedLabelBounds(shape) {
 if (!is$1(shape, 'bpmn:Activity')) {
   return;
 }
51215
 var di = getDi(shape);
51217
 if (!di) {
   return;
 }
51221
 var label = di.get('label');
51223
 if (!label) {
   return;
 }
51227
 return label.get('bounds');
}
51230
/**
* A bpmn-aware factory for diagram-js shapes
*/
function ElementFactory(bpmnFactory, moddle, translate) {
 ElementFactory$1.call(this);
51236
 this._bpmnFactory = bpmnFactory;
 this._moddle = moddle;
 this._translate = translate;
}
51241
inherits$1(ElementFactory, ElementFactory$1);
51243
ElementFactory.$inject = [
 'bpmnFactory',
 'moddle',
 'translate'
];
51249
ElementFactory.prototype.baseCreate = ElementFactory$1.prototype.create;
51251
ElementFactory.prototype.create = function(elementType, attrs) {
51253
 // no special magic for labels,
 // we assume their businessObjects have already been created
 // and wired via attrs
 if (elementType === 'label') {
   var di = attrs.di || this._bpmnFactory.createDiLabel();
   return this.baseCreate(elementType, assign({ type: 'label', di: di }, DEFAULT_LABEL_SIZE, attrs));
 }
51261
 return this.createBpmnElement(elementType, attrs);
};
51264
ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
 var size,
     translate = this._translate;
51268
 attrs = attrs || {};
51270
 var businessObject = attrs.businessObject,
     di = attrs.di;
51273
 if (!businessObject) {
   if (!attrs.type) {
     throw new Error(translate('no shape type specified'));
   }
51278
   businessObject = this._bpmnFactory.create(attrs.type);
51280
   ensureCompatDiRef(businessObject);
 }
51283
 if (!isModdleDi(di)) {
   var diAttrs = assign(
     di || {},
     { id: businessObject.id + '_di' }
   );
51289
   if (elementType === 'root') {
     di = this._bpmnFactory.createDiPlane(businessObject, diAttrs);
   } else
   if (elementType === 'connection') {
     di = this._bpmnFactory.createDiEdge(businessObject, diAttrs);
   } else {
     di = this._bpmnFactory.createDiShape(businessObject, diAttrs);
   }
 }
51299
 if (is$1(businessObject, 'bpmn:Group')) {
   attrs = assign({
     isFrame: true
   }, attrs);
 }
51305
 applyAttributes(businessObject, attrs, [
   'processRef',
   'isInterrupting',
   'associationDirection',
   'isForCompensation'
 ]);
51312
 if (attrs.isExpanded) {
   applyAttribute(di, attrs, 'isExpanded');
 }
51316
 if (is$1(businessObject, 'bpmn:SubProcess')) {
   attrs.collapsed = !isExpanded(businessObject, di);
 }
51320
 if (is$1(businessObject, 'bpmn:ExclusiveGateway')) {
   di.isMarkerVisible = true;
 }
51324
 var eventDefinitions,
     newEventDefinition;
51327
 if (attrs.eventDefinitionType) {
   eventDefinitions = businessObject.get('eventDefinitions') || [];
   newEventDefinition = this._bpmnFactory.create(attrs.eventDefinitionType, attrs.eventDefinitionAttrs);
51331
   if (attrs.eventDefinitionType === 'bpmn:ConditionalEventDefinition') {
     newEventDefinition.condition = this._bpmnFactory.create('bpmn:FormalExpression');
   }
51335
   eventDefinitions.push(newEventDefinition);
51337
   newEventDefinition.$parent = businessObject;
   businessObject.eventDefinitions = eventDefinitions;
51340
   delete attrs.eventDefinitionType;
 }
51343
 size = this.getDefaultSize(businessObject, di);
51345
 attrs = assign({
   id: businessObject.id
 }, size, attrs, {
   businessObject: businessObject,
   di: di
 });
51352
 return this.baseCreate(elementType, attrs);
};
51355
51356
ElementFactory.prototype.getDefaultSize = function(element, di) {
51358
 var bo = getBusinessObject(element);
 di = di || getDi(element);
51361
 if (is$1(bo, 'bpmn:SubProcess')) {
   if (isExpanded(bo, di)) {
     return { width: 350, height: 200 };
   } else {
     return { width: 100, height: 80 };
   }
 }
51369
 if (is$1(bo, 'bpmn:Task')) {
   return { width: 100, height: 80 };
 }
51373
 if (is$1(bo, 'bpmn:Gateway')) {
   return { width: 50, height: 50 };
 }
51377
 if (is$1(bo, 'bpmn:Event')) {
   return { width: 36, height: 36 };
 }
51381
 if (is$1(bo, 'bpmn:Participant')) {
   if (isExpanded(bo, di)) {
     return { width: 600, height: 250 };
   } else {
     return { width: 400, height: 60 };
   }
 }
51389
 if (is$1(bo, 'bpmn:Lane')) {
   return { width: 400, height: 100 };
 }
51393
 if (is$1(bo, 'bpmn:DataObjectReference')) {
   return { width: 36, height: 50 };
 }
51397
 if (is$1(bo, 'bpmn:DataStoreReference')) {
   return { width: 50, height: 50 };
 }
51401
 if (is$1(bo, 'bpmn:TextAnnotation')) {
   return { width: 100, height: 30 };
 }
51405
 if (is$1(bo, 'bpmn:Group')) {
   return { width: 300, height: 300 };
 }
51409
 return { width: 100, height: 80 };
};
51412
51413
/**
* Create participant.
*
* @param {boolean|Object} [attrs] attrs
*
* @returns {djs.model.Shape}
*/
ElementFactory.prototype.createParticipantShape = function(attrs) {
51422
 if (!isObject(attrs)) {
   attrs = { isExpanded: attrs };
 }
51426
 attrs = assign({ type: 'bpmn:Participant' }, attrs || {});
51428
 // participants are expanded by default
 if (attrs.isExpanded !== false) {
   attrs.processRef = this._bpmnFactory.create('bpmn:Process');
 }
51433
 return this.createShape(attrs);
};
51436
51437
// helpers //////////////////////
51439
/**
* Apply attributes from a map to the given element,
* remove attribute from the map on application.
*
* @param {Base} element
* @param {Object} attrs (in/out map of attributes)
* @param {Array<string>} attributeNames name of attributes to apply
*/
function applyAttributes(element, attrs, attributeNames) {
51449
 forEach$2(attributeNames, function(property) {
   if (attrs[property] !== undefined) {
     applyAttribute(element, attrs, property);
   }
 });
}
51456
/**
* Apply named property to element and drain it from the attrs
* collection.
*
* @param {Base} element
* @param {Object} attrs (in/out map of attributes)
* @param {string} attributeName to apply
*/
function applyAttribute(element, attrs, attributeName) {
 element[attributeName] = attrs[attributeName];
51467
 delete attrs[attributeName];
}
51470
51471
function isModdleDi(element) {
 return isAny(element, [
   'bpmndi:BPMNShape',
   'bpmndi:BPMNEdge',
   'bpmndi:BPMNDiagram',
   'bpmndi:BPMNPlane',
 ]);
}
51480
/**
* A handler that align elements in a certain way.
*
*/
function AlignElements(modeling, canvas) {
 this._modeling = modeling;
 this._canvas = canvas;
}
51489
AlignElements.$inject = [ 'modeling', 'canvas' ];
51491
51492
AlignElements.prototype.preExecute = function(context) {
 var modeling = this._modeling;
51495
 var elements = context.elements,
     alignment = context.alignment;
51498
51499
 forEach$2(elements, function(element) {
   var delta = {
     x: 0,
     y: 0
   };
51505
   if (alignment.left) {
     delta.x = alignment.left - element.x;
51508
   } else if (alignment.right) {
     delta.x = (alignment.right - element.width) - element.x;
51511
   } else if (alignment.center) {
     delta.x = (alignment.center - Math.round(element.width / 2)) - element.x;
51514
   } else if (alignment.top) {
     delta.y = alignment.top - element.y;
51517
   } else if (alignment.bottom) {
     delta.y = (alignment.bottom - element.height) - element.y;
51520
   } else if (alignment.middle) {
     delta.y = (alignment.middle - Math.round(element.height / 2)) - element.y;
   }
51524
   modeling.moveElements([ element ], delta, element.parent);
 });
};
51528
AlignElements.prototype.postExecute = function(context) {
51530
};
51532
/**
* A handler that implements reversible appending of shapes
* to a source shape.
*
* @param {canvas} Canvas
* @param {elementFactory} ElementFactory
* @param {modeling} Modeling
*/
function AppendShapeHandler(modeling) {
 this._modeling = modeling;
}
51544
AppendShapeHandler.$inject = [ 'modeling' ];
51546
51547
// api //////////////////////
51549
51550
/**
* Creates a new shape
*
* @param {Object} context
* @param {ElementDescriptor} context.shape the new shape
* @param {ElementDescriptor} context.source the source object
* @param {ElementDescriptor} context.parent the parent object
* @param {Point} context.position position of the new element
*/
AppendShapeHandler.prototype.preExecute = function(context) {
51561
 var source = context.source;
51563
 if (!source) {
   throw new Error('source required');
 }
51567
 var target = context.target || source.parent,
     shape = context.shape,
     hints = context.hints || {};
51571
 shape = context.shape =
   this._modeling.createShape(
     shape,
     context.position,
     target, { attach: hints.attach });
51577
 context.shape = shape;
};
51580
AppendShapeHandler.prototype.postExecute = function(context) {
 var hints = context.hints || {};
51583
 if (!existsConnection(context.source, context.shape)) {
51585
   // create connection
   if (hints.connectionTarget === context.source) {
     this._modeling.connect(context.shape, context.source, context.connection);
   } else {
     this._modeling.connect(context.source, context.shape, context.connection);
   }
 }
};
51594
51595
function existsConnection(source, target) {
 return some(source.outgoing, function(c) {
   return c.target === target;
 });
}
51601
function CreateConnectionHandler(canvas, layouter) {
 this._canvas = canvas;
 this._layouter = layouter;
}
51606
CreateConnectionHandler.$inject = [ 'canvas', 'layouter' ];
51608
51609
// api //////////////////////
51611
51612
/**
* Appends a shape to a target shape
*
* @param {Object} context
* @param {djs.element.Base} context.source the source object
* @param {djs.element.Base} context.target the parent object
* @param {Point} context.position position of the new element
*/
CreateConnectionHandler.prototype.execute = function(context) {
51622
 var connection = context.connection,
     source = context.source,
     target = context.target,
     parent = context.parent,
     parentIndex = context.parentIndex,
     hints = context.hints;
51629
 if (!source || !target) {
   throw new Error('source and target required');
 }
51633
 if (!parent) {
   throw new Error('parent required');
 }
51637
 connection.source = source;
 connection.target = target;
51640
 if (!connection.waypoints) {
   connection.waypoints = this._layouter.layoutConnection(connection, hints);
 }
51644
 // add connection
 this._canvas.addConnection(connection, parent, parentIndex);
51647
 return connection;
};
51650
CreateConnectionHandler.prototype.revert = function(context) {
 var connection = context.connection;
51653
 this._canvas.removeConnection(connection);
51655
 connection.source = null;
 connection.target = null;
51658
 return connection;
};
51661
var round$3 = Math.round;
51663
function CreateElementsHandler(modeling) {
 this._modeling = modeling;
}
51667
CreateElementsHandler.$inject = [
 'modeling'
];
51671
CreateElementsHandler.prototype.preExecute = function(context) {
 var elements = context.elements,
     parent = context.parent,
     parentIndex = context.parentIndex,
     position = context.position,
     hints = context.hints;
51678
 var modeling = this._modeling;
51680
 // make sure each element has x and y
 forEach$2(elements, function(element) {
   if (!isNumber(element.x)) {
     element.x = 0;
   }
51686
   if (!isNumber(element.y)) {
     element.y = 0;
   }
 });
51691
 var visibleElements = filter(elements, function(element) {
   return !element.hidden;
 });
51695
 var bbox = getBBox(visibleElements);
51697
 // center elements around position
 forEach$2(elements, function(element) {
   if (isConnection$5(element)) {
     element.waypoints = map(element.waypoints, function(waypoint) {
       return {
         x: round$3(waypoint.x - bbox.x - bbox.width / 2 + position.x),
         y: round$3(waypoint.y - bbox.y - bbox.height / 2 + position.y)
       };
     });
   }
51708
   assign(element, {
     x: round$3(element.x - bbox.x - bbox.width / 2 + position.x),
     y: round$3(element.y - bbox.y - bbox.height / 2 + position.y)
   });
 });
51714
 var parents = getParents$1(elements);
51716
 var cache = {};
51718
 forEach$2(elements, function(element) {
   if (isConnection$5(element)) {
     cache[ element.id ] = isNumber(parentIndex) ?
       modeling.createConnection(
         cache[ element.source.id ],
         cache[ element.target.id ],
         parentIndex,
         element,
         element.parent || parent,
         hints
       ) :
       modeling.createConnection(
         cache[ element.source.id ],
         cache[ element.target.id ],
         element,
         element.parent || parent,
         hints
       );
51737
     return;
   }
51740
   var createShapeHints = assign({}, hints);
51742
   if (parents.indexOf(element) === -1) {
     createShapeHints.autoResize = false;
   }
51746
   cache[ element.id ] = isNumber(parentIndex) ?
     modeling.createShape(
       element,
       pick(element, [ 'x', 'y', 'width', 'height' ]),
       element.parent || parent,
       parentIndex,
       createShapeHints
     ) :
     modeling.createShape(
       element,
       pick(element, [ 'x', 'y', 'width', 'height' ]),
       element.parent || parent,
       createShapeHints
     );
 });
51762
 context.elements = values(cache);
};
51765
// helpers //////////
51767
function isConnection$5(element) {
 return !!element.waypoints;
}
51771
var round$2 = Math.round;
51773
51774
/**
* A handler that implements reversible addition of shapes.
*
* @param {canvas} Canvas
*/
function CreateShapeHandler(canvas) {
 this._canvas = canvas;
}
51783
CreateShapeHandler.$inject = [ 'canvas' ];
51785
51786
// api //////////////////////
51788
51789
/**
* Appends a shape to a target shape
*
* @param {Object} context
* @param {djs.model.Base} context.parent the parent object
* @param {Point} context.position position of the new element
*/
CreateShapeHandler.prototype.execute = function(context) {
51798
 var shape = context.shape,
     positionOrBounds = context.position,
     parent = context.parent,
     parentIndex = context.parentIndex;
51803
 if (!parent) {
   throw new Error('parent required');
 }
51807
 if (!positionOrBounds) {
   throw new Error('position required');
 }
51811
 // (1) add at event center position _or_ at given bounds
 if (positionOrBounds.width !== undefined) {
   assign(shape, positionOrBounds);
 } else {
   assign(shape, {
     x: positionOrBounds.x - round$2(shape.width / 2),
     y: positionOrBounds.y - round$2(shape.height / 2)
   });
 }
51821
 // (2) add to canvas
 this._canvas.addShape(shape, parent, parentIndex);
51824
 return shape;
};
51827
51828
/**
* Undo append by removing the shape
*/
CreateShapeHandler.prototype.revert = function(context) {
51833
 var shape = context.shape;
51835
 // (3) remove form canvas
 this._canvas.removeShape(shape);
51838
 return shape;
};
51841
/**
* A handler that attaches a label to a given target shape.
*
* @param {Canvas} canvas
*/
function CreateLabelHandler(canvas) {
 CreateShapeHandler.call(this, canvas);
}
51850
inherits$1(CreateLabelHandler, CreateShapeHandler);
51852
CreateLabelHandler.$inject = [ 'canvas' ];
51854
51855
// api //////////////////////
51857
51858
var originalExecute = CreateShapeHandler.prototype.execute;
51860
/**
* Appends a label to a target shape.
*
* @method CreateLabelHandler#execute
*
* @param {Object} context
* @param {ElementDescriptor} context.target the element the label is attached to
* @param {ElementDescriptor} context.parent the parent object
* @param {Point} context.position position of the new element
*/
CreateLabelHandler.prototype.execute = function(context) {
51872
 var label = context.shape;
51874
 ensureValidDimensions(label);
51876
 label.labelTarget = context.labelTarget;
51878
 return originalExecute.call(this, context);
};
51881
var originalRevert = CreateShapeHandler.prototype.revert;
51883
/**
* Undo append by removing the shape
*/
CreateLabelHandler.prototype.revert = function(context) {
 context.shape.labelTarget = null;
51889
 return originalRevert.call(this, context);
};
51892
51893
// helpers //////////////////////
51895
function ensureValidDimensions(label) {
51897
 // make sure a label has valid { width, height } dimensions
 [ 'width', 'height' ].forEach(function(prop) {
   if (typeof label[prop] === 'undefined') {
     label[prop] = 0;
   }
 });
}
51905
/**
* A handler that implements reversible deletion of Connections.
*/
function DeleteConnectionHandler(canvas, modeling) {
 this._canvas = canvas;
 this._modeling = modeling;
}
51913
DeleteConnectionHandler.$inject = [
 'canvas',
 'modeling'
];
51918
51919
DeleteConnectionHandler.prototype.execute = function(context) {
51921
 var connection = context.connection,
     parent = connection.parent;
51924
 context.parent = parent;
51926
 // remember containment
 context.parentIndex = indexOf(parent.children, connection);
51929
 context.source = connection.source;
 context.target = connection.target;
51932
 this._canvas.removeConnection(connection);
51934
 connection.source = null;
 connection.target = null;
51937
 return connection;
};
51940
/**
* Command revert implementation.
*/
DeleteConnectionHandler.prototype.revert = function(context) {
51945
 var connection = context.connection,
     parent = context.parent,
     parentIndex = context.parentIndex;
51949
 connection.source = context.source;
 connection.target = context.target;
51952
 // restore containment
 add(parent.children, connection, parentIndex);
51955
 this._canvas.addConnection(connection, parent);
51957
 return connection;
};
51960
function DeleteElementsHandler(modeling, elementRegistry) {
 this._modeling = modeling;
 this._elementRegistry = elementRegistry;
}
51965
DeleteElementsHandler.$inject = [
 'modeling',
 'elementRegistry'
];
51970
51971
DeleteElementsHandler.prototype.postExecute = function(context) {
51973
 var modeling = this._modeling,
     elementRegistry = this._elementRegistry,
     elements = context.elements;
51977
 forEach$2(elements, function(element) {
51979
   // element may have been removed with previous
   // remove operations already (e.g. in case of nesting)
   if (!elementRegistry.get(element.id)) {
     return;
   }
51985
   if (element.waypoints) {
     modeling.removeConnection(element);
   } else {
     modeling.removeShape(element);
   }
 });
};
51993
/**
* A handler that implements reversible deletion of shapes.
*
*/
function DeleteShapeHandler(canvas, modeling) {
 this._canvas = canvas;
 this._modeling = modeling;
}
52002
DeleteShapeHandler.$inject = [ 'canvas', 'modeling' ];
52004
52005
/**
* - Remove connections
* - Remove all direct children
*/
DeleteShapeHandler.prototype.preExecute = function(context) {
52011
 var modeling = this._modeling;
52013
 var shape = context.shape;
52015
 // remove connections
 saveClear(shape.incoming, function(connection) {
52018
   // To make sure that the connection isn't removed twice
   // For example if a container is removed
   modeling.removeConnection(connection, { nested: true });
 });
52023
 saveClear(shape.outgoing, function(connection) {
   modeling.removeConnection(connection, { nested: true });
 });
52027
 // remove child shapes and connections
 saveClear(shape.children, function(child) {
   if (isConnection$4(child)) {
     modeling.removeConnection(child, { nested: true });
   } else {
     modeling.removeShape(child, { nested: true });
   }
 });
};
52037
/**
* Remove shape and remember the parent
*/
DeleteShapeHandler.prototype.execute = function(context) {
 var canvas = this._canvas;
52043
 var shape = context.shape,
     oldParent = shape.parent;
52046
 context.oldParent = oldParent;
52048
 // remove containment
 context.oldParentIndex = indexOf(oldParent.children, shape);
52051
 // remove shape
 canvas.removeShape(shape);
52054
 return shape;
};
52057
52058
/**
* Command revert implementation
*/
DeleteShapeHandler.prototype.revert = function(context) {
52063
 var canvas = this._canvas;
52065
 var shape = context.shape,
     oldParent = context.oldParent,
     oldParentIndex = context.oldParentIndex;
52069
 // restore containment
 add(oldParent.children, shape, oldParentIndex);
52072
 canvas.addShape(shape, oldParent);
52074
 return shape;
};
52077
function isConnection$4(element) {
 return element.waypoints;
}
52081
/**
* A handler that distributes elements evenly.
*/
function DistributeElements(modeling) {
 this._modeling = modeling;
}
52088
DistributeElements.$inject = [ 'modeling' ];
52090
var OFF_AXIS = {
 x: 'y',
 y: 'x'
};
52095
DistributeElements.prototype.preExecute = function(context) {
 var modeling = this._modeling;
52098
 var groups = context.groups,
     axis = context.axis,
     dimension = context.dimension;
52102
 function updateRange(group, element) {
   group.range.min = Math.min(element[axis], group.range.min);
   group.range.max = Math.max(element[axis] + element[dimension], group.range.max);
 }
52107
 function center(element) {
   return element[axis] + element[dimension] / 2;
 }
52111
 function lastIdx(arr) {
   return arr.length - 1;
 }
52115
 function rangeDiff(range) {
   return range.max - range.min;
 }
52119
 function centerElement(refCenter, element) {
   var delta = { y: 0 };
52122
   delta[axis] = refCenter - center(element);
52124
   if (delta[axis]) {
52126
     delta[OFF_AXIS[axis]] = 0;
52128
     modeling.moveElements([ element ], delta, element.parent);
   }
 }
52132
 var firstGroup = groups[0],
     lastGroupIdx = lastIdx(groups),
     lastGroup = groups[ lastGroupIdx ];
52136
 var margin,
     spaceInBetween,
     groupsSize = 0; // the size of each range
52140
 forEach$2(groups, function(group, idx) {
   var sortedElements,
       refElem,
       refCenter;
52145
   if (group.elements.length < 2) {
     if (idx && idx !== groups.length - 1) {
       updateRange(group, group.elements[0]);
52149
       groupsSize += rangeDiff(group.range);
     }
     return;
   }
52154
   sortedElements = sortBy(group.elements, axis);
52156
   refElem = sortedElements[0];
52158
   if (idx === lastGroupIdx) {
     refElem = sortedElements[lastIdx(sortedElements)];
   }
52162
   refCenter = center(refElem);
52164
   // wanna update the ranges after the shapes have been centered
   group.range = null;
52167
   forEach$2(sortedElements, function(element) {
52169
     centerElement(refCenter, element);
52171
     if (group.range === null) {
       group.range = {
         min: element[axis],
         max: element[axis] + element[dimension]
       };
52177
       return;
     }
52180
     // update group's range after centering the range elements
     updateRange(group, element);
   });
52184
   if (idx && idx !== groups.length - 1) {
     groupsSize += rangeDiff(group.range);
   }
 });
52189
 spaceInBetween = Math.abs(lastGroup.range.min - firstGroup.range.max);
52191
 margin = Math.round((spaceInBetween - groupsSize) / (groups.length - 1));
52193
 if (margin < groups.length - 1) {
   return;
 }
52197
 forEach$2(groups, function(group, groupIdx) {
   var delta = {},
       prevGroup;
52201
   if (group === firstGroup || group === lastGroup) {
     return;
   }
52205
   prevGroup = groups[groupIdx - 1];
52207
   group.range.max = 0;
52209
   forEach$2(group.elements, function(element, idx) {
     delta[OFF_AXIS[axis]] = 0;
     delta[axis] = (prevGroup.range.max - element[axis]) + margin;
52213
     if (group.range.min !== element[axis]) {
       delta[axis] += element[axis] - group.range.min;
     }
52217
     if (delta[axis]) {
       modeling.moveElements([ element ], delta, element.parent);
     }
52221
     group.range.max = Math.max(element[axis] + element[dimension], idx ? group.range.max : 0);
   });
 });
};
52226
DistributeElements.prototype.postExecute = function(context) {
52228
};
52230
/**
* A handler that implements reversible moving of shapes.
*/
function LayoutConnectionHandler(layouter, canvas) {
 this._layouter = layouter;
 this._canvas = canvas;
}
52238
LayoutConnectionHandler.$inject = [ 'layouter', 'canvas' ];
52240
LayoutConnectionHandler.prototype.execute = function(context) {
52242
 var connection = context.connection;
52244
 var oldWaypoints = connection.waypoints;
52246
 assign(context, {
   oldWaypoints: oldWaypoints
 });
52250
 connection.waypoints = this._layouter.layoutConnection(connection, context.hints);
52252
 return connection;
};
52255
LayoutConnectionHandler.prototype.revert = function(context) {
52257
 var connection = context.connection;
52259
 connection.waypoints = context.oldWaypoints;
52261
 return connection;
};
52264
/**
* A handler that implements reversible moving of connections.
*
* The handler differs from the layout connection handler in a sense
* that it preserves the connection layout.
*/
function MoveConnectionHandler() { }
52272
52273
MoveConnectionHandler.prototype.execute = function(context) {
52275
 var connection = context.connection,
     delta = context.delta;
52278
 var newParent = context.newParent || connection.parent,
     newParentIndex = context.newParentIndex,
     oldParent = connection.parent;
52282
 // save old parent in context
 context.oldParent = oldParent;
 context.oldParentIndex = remove(oldParent.children, connection);
52286
 // add to new parent at position
 add(newParent.children, connection, newParentIndex);
52289
 // update parent
 connection.parent = newParent;
52292
 // update waypoint positions
 forEach$2(connection.waypoints, function(p) {
   p.x += delta.x;
   p.y += delta.y;
52297
   if (p.original) {
     p.original.x += delta.x;
     p.original.y += delta.y;
   }
 });
52303
 return connection;
};
52306
MoveConnectionHandler.prototype.revert = function(context) {
52308
 var connection = context.connection,
     newParent = connection.parent,
     oldParent = context.oldParent,
     oldParentIndex = context.oldParentIndex,
     delta = context.delta;
52314
 // remove from newParent
 remove(newParent.children, connection);
52317
 // restore previous location in old parent
 add(oldParent.children, connection, oldParentIndex);
52320
 // restore parent
 connection.parent = oldParent;
52323
 // revert to old waypoint positions
 forEach$2(connection.waypoints, function(p) {
   p.x -= delta.x;
   p.y -= delta.y;
52328
   if (p.original) {
     p.original.x -= delta.x;
     p.original.y -= delta.y;
   }
 });
52334
 return connection;
};
52337
function MoveClosure() {
52339
 this.allShapes = {};
 this.allConnections = {};
52342
 this.enclosedElements = {};
 this.enclosedConnections = {};
52345
 this.topLevel = {};
}
52348
52349
MoveClosure.prototype.add = function(element, isTopLevel) {
 return this.addAll([ element ], isTopLevel);
};
52353
52354
MoveClosure.prototype.addAll = function(elements, isTopLevel) {
52356
 var newClosure = getClosure(elements, !!isTopLevel, this);
52358
 assign(this, newClosure);
52360
 return this;
};
52363
/**
* A helper that is able to carry out serialized move
* operations on multiple elements.
*
* @param {Modeling} modeling
*/
function MoveHelper(modeling) {
 this._modeling = modeling;
}
52373
/**
* Move the specified elements and all children by the given delta.
*
* This moves all enclosed connections, too and layouts all affected
* external connections.
*
* @param  {Array<djs.model.Base>} elements
* @param  {Point} delta
* @param  {djs.model.Base} newParent applied to the first level of shapes
*
* @return {Array<djs.model.Base>} list of touched elements
*/
MoveHelper.prototype.moveRecursive = function(elements, delta, newParent) {
 if (!elements) {
   return [];
 } else {
   return this.moveClosure(this.getClosure(elements), delta, newParent);
 }
};
52393
/**
* Move the given closure of elmements.
*
* @param {Object} closure
* @param {Point} delta
* @param {djs.model.Base} [newParent]
* @param {djs.model.Base} [newHost]
*/
MoveHelper.prototype.moveClosure = function(closure, delta, newParent, newHost, primaryShape) {
 var modeling = this._modeling;
52404
 var allShapes = closure.allShapes,
     allConnections = closure.allConnections,
     enclosedConnections = closure.enclosedConnections,
     topLevel = closure.topLevel,
     keepParent = false;
52410
 if (primaryShape && primaryShape.parent === newParent) {
   keepParent = true;
 }
52414
 // move all shapes
 forEach$2(allShapes, function(shape) {
52417
   // move the element according to the given delta
   modeling.moveShape(shape, delta, topLevel[shape.id] && !keepParent && newParent, {
     recurse: false,
     layout: false
   });
 });
52424
 // move all child connections / layout external connections
 forEach$2(allConnections, function(c) {
52427
   var sourceMoved = !!allShapes[c.source.id],
       targetMoved = !!allShapes[c.target.id];
52430
   if (enclosedConnections[c.id] && sourceMoved && targetMoved) {
     modeling.moveConnection(c, delta, topLevel[c.id] && !keepParent && newParent);
   } else {
     modeling.layoutConnection(c, {
       connectionStart: sourceMoved && getMovedSourceAnchor(c, c.source, delta),
       connectionEnd: targetMoved && getMovedTargetAnchor(c, c.target, delta)
     });
   }
 });
};
52441
/**
* Returns the closure for the selected elements
*
* @param  {Array<djs.model.Base>} elements
* @return {MoveClosure} closure
*/
MoveHelper.prototype.getClosure = function(elements) {
 return new MoveClosure().addAll(elements, true);
};
52451
/**
* A handler that implements reversible moving of shapes.
*/
function MoveElementsHandler(modeling) {
 this._helper = new MoveHelper(modeling);
}
52458
MoveElementsHandler.$inject = [ 'modeling' ];
52460
MoveElementsHandler.prototype.preExecute = function(context) {
 context.closure = this._helper.getClosure(context.shapes);
};
52464
MoveElementsHandler.prototype.postExecute = function(context) {
52466
 var hints = context.hints,
     primaryShape;
52469
 if (hints && hints.primaryShape) {
   primaryShape = hints.primaryShape;
   hints.oldParent = primaryShape.parent;
 }
52474
 this._helper.moveClosure(
   context.closure,
   context.delta,
   context.newParent,
   context.newHost,
   primaryShape
 );
};
52483
/**
* A handler that implements reversible moving of shapes.
*/
function MoveShapeHandler(modeling) {
 this._modeling = modeling;
52489
 this._helper = new MoveHelper(modeling);
}
52492
MoveShapeHandler.$inject = [ 'modeling' ];
52494
52495
MoveShapeHandler.prototype.execute = function(context) {
52497
 var shape = context.shape,
     delta = context.delta,
     newParent = context.newParent || shape.parent,
     newParentIndex = context.newParentIndex,
     oldParent = shape.parent;
52503
 context.oldBounds = pick(shape, [ 'x', 'y', 'width', 'height' ]);
52505
 // save old parent in context
 context.oldParent = oldParent;
 context.oldParentIndex = remove(oldParent.children, shape);
52509
 // add to new parent at position
 add(newParent.children, shape, newParentIndex);
52512
 // update shape parent + position
 assign(shape, {
   parent: newParent,
   x: shape.x + delta.x,
   y: shape.y + delta.y
 });
52519
 return shape;
};
52522
MoveShapeHandler.prototype.postExecute = function(context) {
52524
 var shape = context.shape,
     delta = context.delta,
     hints = context.hints;
52528
 var modeling = this._modeling;
52530
 if (hints.layout !== false) {
52532
   forEach$2(shape.incoming, function(c) {
     modeling.layoutConnection(c, {
       connectionEnd: getMovedTargetAnchor(c, shape, delta)
     });
   });
52538
   forEach$2(shape.outgoing, function(c) {
     modeling.layoutConnection(c, {
       connectionStart: getMovedSourceAnchor(c, shape, delta)
     });
   });
 }
52545
 if (hints.recurse !== false) {
   this.moveChildren(context);
 }
};
52550
MoveShapeHandler.prototype.revert = function(context) {
52552
 var shape = context.shape,
     oldParent = context.oldParent,
     oldParentIndex = context.oldParentIndex,
     delta = context.delta;
52557
 // restore previous location in old parent
 add(oldParent.children, shape, oldParentIndex);
52560
 // revert to old position and parent
 assign(shape, {
   parent: oldParent,
   x: shape.x - delta.x,
   y: shape.y - delta.y
 });
52567
 return shape;
};
52570
MoveShapeHandler.prototype.moveChildren = function(context) {
52572
 var delta = context.delta,
     shape = context.shape;
52575
 this._helper.moveRecursive(shape.children, delta, null);
};
52578
MoveShapeHandler.prototype.getNewParent = function(context) {
 return context.newParent || context.shape.parent;
};
52582
/**
* Reconnect connection handler
*/
function ReconnectConnectionHandler(modeling) {
 this._modeling = modeling;
}
52589
ReconnectConnectionHandler.$inject = [ 'modeling' ];
52591
ReconnectConnectionHandler.prototype.execute = function(context) {
 var newSource = context.newSource,
     newTarget = context.newTarget,
     connection = context.connection,
     dockingOrPoints = context.dockingOrPoints;
52597
 if (!newSource && !newTarget) {
   throw new Error('newSource or newTarget required');
 }
52601
 if (isArray$4(dockingOrPoints)) {
   context.oldWaypoints = connection.waypoints;
   connection.waypoints = dockingOrPoints;
 }
52606
 if (newSource) {
   context.oldSource = connection.source;
   connection.source = newSource;
 }
52611
 if (newTarget) {
   context.oldTarget = connection.target;
   connection.target = newTarget;
 }
52616
 return connection;
};
52619
ReconnectConnectionHandler.prototype.postExecute = function(context) {
 var connection = context.connection,
     newSource = context.newSource,
     newTarget = context.newTarget,
     dockingOrPoints = context.dockingOrPoints,
     hints = context.hints || {};
52626
 var layoutConnectionHints = {};
52628
 if (hints.connectionStart) {
   layoutConnectionHints.connectionStart = hints.connectionStart;
 }
52632
 if (hints.connectionEnd) {
   layoutConnectionHints.connectionEnd = hints.connectionEnd;
 }
52636
 if (hints.layoutConnection === false) {
   return;
 }
52640
 if (newSource && (!newTarget || hints.docking === 'source')) {
   layoutConnectionHints.connectionStart = layoutConnectionHints.connectionStart
     || getDocking(isArray$4(dockingOrPoints) ? dockingOrPoints[ 0 ] : dockingOrPoints);
 }
52645
 if (newTarget && (!newSource || hints.docking === 'target')) {
   layoutConnectionHints.connectionEnd = layoutConnectionHints.connectionEnd
     || getDocking(isArray$4(dockingOrPoints) ? dockingOrPoints[ dockingOrPoints.length - 1 ] : dockingOrPoints);
 }
52650
 if (hints.newWaypoints) {
   layoutConnectionHints.waypoints = hints.newWaypoints;
 }
52654
 this._modeling.layoutConnection(connection, layoutConnectionHints);
};
52657
ReconnectConnectionHandler.prototype.revert = function(context) {
 var oldSource = context.oldSource,
     oldTarget = context.oldTarget,
     oldWaypoints = context.oldWaypoints,
     connection = context.connection;
52663
 if (oldSource) {
   connection.source = oldSource;
 }
52667
 if (oldTarget) {
   connection.target = oldTarget;
 }
52671
 if (oldWaypoints) {
   connection.waypoints = oldWaypoints;
 }
52675
 return connection;
};
52678
52679
52680
// helpers //////////
52682
function getDocking(point) {
 return point.original || point;
}
52686
/**
* Replace shape by adding new shape and removing old shape. Incoming and outgoing connections will
* be kept if possible.
*
* @class
* @constructor
*
* @param {Modeling} modeling
* @param {Rules} rules
*/
function ReplaceShapeHandler(modeling, rules) {
 this._modeling = modeling;
 this._rules = rules;
}
52701
ReplaceShapeHandler.$inject = [ 'modeling', 'rules' ];
52703
52704
/**
* Add new shape.
*
* @param {Object} context
* @param {djs.model.Shape} context.oldShape
* @param {Object} context.newData
* @param {string} context.newData.type
* @param {number} context.newData.x
* @param {number} context.newData.y
* @param {Object} [hints]
*/
ReplaceShapeHandler.prototype.preExecute = function(context) {
 var self = this,
     modeling = this._modeling,
     rules = this._rules;
52720
 var oldShape = context.oldShape,
     newData = context.newData,
     hints = context.hints || {},
     newShape;
52725
 function canReconnect(source, target, connection) {
   return rules.allowed('connection.reconnect', {
     connection: connection,
     source: source,
     target: target
   });
 }
52733
 // (1) add new shape at given position
 var position = {
   x: newData.x,
   y: newData.y
 };
52739
 var oldBounds = {
   x: oldShape.x,
   y: oldShape.y,
   width: oldShape.width,
   height: oldShape.height
 };
52746
 newShape = context.newShape =
   context.newShape ||
   self.createShape(newData, position, oldShape.parent, hints);
52750
 // (2) update host
 if (oldShape.host) {
   modeling.updateAttachment(newShape, oldShape.host);
 }
52755
 // (3) adopt all children from old shape
 var children;
52758
 if (hints.moveChildren !== false) {
   children = oldShape.children.slice();
52761
   modeling.moveElements(children, { x: 0, y: 0 }, newShape, hints);
 }
52764
 // (4) reconnect connections to new shape if possible
 var incoming = oldShape.incoming.slice(),
     outgoing = oldShape.outgoing.slice();
52768
 forEach$2(incoming, function(connection) {
   var source = connection.source,
       allowed = canReconnect(source, newShape, connection);
52772
   if (allowed) {
     self.reconnectEnd(
       connection, newShape,
       getResizedTargetAnchor(connection, newShape, oldBounds),
       hints
     );
   }
 });
52781
 forEach$2(outgoing, function(connection) {
   var target = connection.target,
       allowed = canReconnect(newShape, target, connection);
52785
   if (allowed) {
     self.reconnectStart(
       connection, newShape,
       getResizedSourceAnchor(connection, newShape, oldBounds),
       hints
     );
   }
 });
};
52795
52796
/**
* Remove old shape.
*/
ReplaceShapeHandler.prototype.postExecute = function(context) {
 var oldShape = context.oldShape;
52802
 this._modeling.removeShape(oldShape);
};
52805
52806
ReplaceShapeHandler.prototype.execute = function(context) {};
52808
52809
ReplaceShapeHandler.prototype.revert = function(context) {};
52811
52812
ReplaceShapeHandler.prototype.createShape = function(shape, position, target, hints) {
 return this._modeling.createShape(shape, position, target, hints);
};
52816
52817
ReplaceShapeHandler.prototype.reconnectStart = function(connection, newSource, dockingPoint, hints) {
 this._modeling.reconnectStart(connection, newSource, dockingPoint, hints);
};
52821
52822
ReplaceShapeHandler.prototype.reconnectEnd = function(connection, newTarget, dockingPoint, hints) {
 this._modeling.reconnectEnd(connection, newTarget, dockingPoint, hints);
};
52826
/**
* A handler that implements reversible resizing of shapes.
*
* @param {Modeling} modeling
*/
function ResizeShapeHandler(modeling) {
 this._modeling = modeling;
}
52835
ResizeShapeHandler.$inject = [ 'modeling' ];
52837
/**
* {
*   shape: {....}
*   newBounds: {
*     width:  20,
*     height: 40,
*     x:       5,
*     y:      10
*   }
*
* }
*/
ResizeShapeHandler.prototype.execute = function(context) {
 var shape = context.shape,
     newBounds = context.newBounds,
     minBounds = context.minBounds;
52854
 if (newBounds.x === undefined || newBounds.y === undefined ||
     newBounds.width === undefined || newBounds.height === undefined) {
   throw new Error('newBounds must have {x, y, width, height} properties');
 }
52859
 if (minBounds && (newBounds.width < minBounds.width
   || newBounds.height < minBounds.height)) {
   throw new Error('width and height cannot be less than minimum height and width');
 } else if (!minBounds
   && newBounds.width < 10 || newBounds.height < 10) {
   throw new Error('width and height cannot be less than 10px');
 }
52867
 // save old bbox in context
 context.oldBounds = {
   width:  shape.width,
   height: shape.height,
   x:      shape.x,
   y:      shape.y
 };
52875
 // update shape
 assign(shape, {
   width:  newBounds.width,
   height: newBounds.height,
   x:      newBounds.x,
   y:      newBounds.y
 });
52883
 return shape;
};
52886
ResizeShapeHandler.prototype.postExecute = function(context) {
 var modeling = this._modeling;
52889
 var shape = context.shape,
     oldBounds = context.oldBounds,
     hints = context.hints || {};
52893
 if (hints.layout === false) {
   return;
 }
52897
 forEach$2(shape.incoming, function(c) {
   modeling.layoutConnection(c, {
     connectionEnd: getResizedTargetAnchor(c, shape, oldBounds)
   });
 });
52903
 forEach$2(shape.outgoing, function(c) {
   modeling.layoutConnection(c, {
     connectionStart: getResizedSourceAnchor(c, shape, oldBounds)
   });
 });
52909
};
52911
ResizeShapeHandler.prototype.revert = function(context) {
52913
 var shape = context.shape,
     oldBounds = context.oldBounds;
52916
 // restore previous bbox
 assign(shape, {
   width:  oldBounds.width,
   height: oldBounds.height,
   x:      oldBounds.x,
   y:      oldBounds.y
 });
52924
 return shape;
};
52927
/**
* Add or remove space by moving and resizing shapes and updating connection waypoints.
*/
function SpaceToolHandler(modeling) {
 this._modeling = modeling;
}
52934
SpaceToolHandler.$inject = [ 'modeling' ];
52936
SpaceToolHandler.prototype.preExecute = function(context) {
 var delta = context.delta,
     direction = context.direction,
     movingShapes = context.movingShapes,
     resizingShapes = context.resizingShapes,
     start = context.start,
     oldBounds = {};
52944
 // (1) move shapes
 this.moveShapes(movingShapes, delta);
52947
 // (2a) save old bounds of resized shapes
 forEach$2(resizingShapes, function(shape) {
   oldBounds[shape.id] = getBounds(shape);
 });
52952
 // (2b) resize shapes
 this.resizeShapes(resizingShapes, delta, direction);
52955
 // (3) update connection waypoints
 this.updateConnectionWaypoints(
   getWaypointsUpdatingConnections(movingShapes, resizingShapes),
   delta,
   direction,
   start,
   movingShapes,
   resizingShapes,
   oldBounds
 );
};
52967
SpaceToolHandler.prototype.execute = function() {};
SpaceToolHandler.prototype.revert = function() {};
52970
SpaceToolHandler.prototype.moveShapes = function(shapes, delta) {
 var self = this;
52973
 forEach$2(shapes, function(element) {
   self._modeling.moveShape(element, delta, null, {
     autoResize: false,
     layout: false,
     recurse: false
   });
 });
};
52982
SpaceToolHandler.prototype.resizeShapes = function(shapes, delta, direction) {
 var self = this;
52985
 forEach$2(shapes, function(shape) {
   var newBounds = resizeBounds(shape, direction, delta);
52988
   self._modeling.resizeShape(shape, newBounds, null, {
     attachSupport: false,
     autoResize: false,
     layout: false
   });
 });
};
52996
/**
* Update connections waypoints according to the rules:
*   1. Both source and target are moved/resized => move waypoints by the delta
*   2. Only one of source and target is moved/resized => re-layout connection with moved start/end
*/
SpaceToolHandler.prototype.updateConnectionWaypoints = function(
   connections,
   delta,
   direction,
   start,
   movingShapes,
   resizingShapes,
   oldBounds
) {
 var self = this,
     affectedShapes = movingShapes.concat(resizingShapes);
53013
 forEach$2(connections, function(connection) {
   var source = connection.source,
       target = connection.target,
       waypoints = copyWaypoints(connection),
       axis = getAxisFromDirection(direction),
       layoutHints = {
         labelBehavior: false
       };
53022
   if (includes$1(affectedShapes, source) && includes$1(affectedShapes, target)) {
53024
     // move waypoints
     waypoints = map(waypoints, function(waypoint) {
       if (shouldMoveWaypoint(waypoint, start, direction)) {
53028
         // move waypoint
         waypoint[ axis ] = waypoint[ axis ] + delta[ axis ];
       }
53032
       if (waypoint.original && shouldMoveWaypoint(waypoint.original, start, direction)) {
53034
         // move waypoint original
         waypoint.original[ axis ] = waypoint.original[ axis ] + delta[ axis ];
       }
53038
       return waypoint;
     });
53041
     self._modeling.updateWaypoints(connection, waypoints, {
       labelBehavior: false
     });
   } else if (includes$1(affectedShapes, source) || includes$1(affectedShapes, target)) {
53046
     // re-layout connection with moved start/end
     if (includes$1(movingShapes, source)) {
       layoutHints.connectionStart = getMovedSourceAnchor(connection, source, delta);
     } else if (includes$1(movingShapes, target)) {
       layoutHints.connectionEnd = getMovedTargetAnchor(connection, target, delta);
     } else if (includes$1(resizingShapes, source)) {
       layoutHints.connectionStart = getResizedSourceAnchor(
         connection, source, oldBounds[source.id]
       );
     } else if (includes$1(resizingShapes, target)) {
       layoutHints.connectionEnd = getResizedTargetAnchor(
         connection, target, oldBounds[target.id]
       );
     }
53061
     self._modeling.layoutConnection(connection, layoutHints);
   }
 });
};
53066
53067
// helpers //////////
53069
function copyWaypoint(waypoint) {
 return assign({}, waypoint);
}
53073
function copyWaypoints(connection) {
 return map(connection.waypoints, function(waypoint) {
53076
   waypoint = copyWaypoint(waypoint);
53078
   if (waypoint.original) {
     waypoint.original = copyWaypoint(waypoint.original);
   }
53082
   return waypoint;
 });
}
53086
function getAxisFromDirection(direction) {
 switch (direction) {
 case 'n':
   return 'y';
 case 'w':
   return 'x';
 case 's':
   return 'y';
 case 'e':
   return 'x';
 }
}
53099
function shouldMoveWaypoint(waypoint, start, direction) {
 var relevantAxis = getAxisFromDirection(direction);
53102
 if (/e|s/.test(direction)) {
   return waypoint[ relevantAxis ] > start;
 } else if (/n|w/.test(direction)) {
   return waypoint[ relevantAxis ] < start;
 }
}
53109
function includes$1(array, item) {
 return array.indexOf(item) !== -1;
}
53113
function getBounds(shape) {
 return {
   x: shape.x,
   y: shape.y,
   height: shape.height,
   width: shape.width
 };
}
53122
/**
* A handler that toggles the collapsed state of an element
* and the visibility of all its children.
*
* @param {Modeling} modeling
*/
function ToggleShapeCollapseHandler(modeling) {
 this._modeling = modeling;
}
53132
ToggleShapeCollapseHandler.$inject = [ 'modeling' ];
53134
53135
ToggleShapeCollapseHandler.prototype.execute = function(context) {
53137
 var shape = context.shape,
     children = shape.children;
53140
 // recursively remember previous visibility of children
 context.oldChildrenVisibility = getElementsVisibilityRecursive(children);
53143
 // toggle state
 shape.collapsed = !shape.collapsed;
53146
 // recursively hide/show children
 var result = setHiddenRecursive(children, shape.collapsed);
53149
 return [ shape ].concat(result);
};
53152
53153
ToggleShapeCollapseHandler.prototype.revert = function(context) {
53155
 var shape = context.shape,
     oldChildrenVisibility = context.oldChildrenVisibility;
53158
 var children = shape.children;
53160
 // recursively set old visability of children
 var result = restoreVisibilityRecursive(children, oldChildrenVisibility);
53163
 // retoggle state
 shape.collapsed = !shape.collapsed;
53166
 return [ shape ].concat(result);
};
53169
53170
// helpers //////////////////////
53172
/**
* Return a map { elementId -> hiddenState}.
*
* @param {Array<djs.model.Shape>} elements
*
* @return {Object}
*/
function getElementsVisibilityRecursive(elements) {
53181
 var result = {};
53183
 forEach$2(elements, function(element) {
   result[element.id] = element.hidden;
53186
   if (element.children) {
     result = assign({}, result, getElementsVisibilityRecursive(element.children));
   }
 });
53191
 return result;
}
53194
53195
function setHiddenRecursive(elements, newHidden) {
 var result = [];
 forEach$2(elements, function(element) {
   element.hidden = newHidden;
53200
   result = result.concat(element);
53202
   if (element.children) {
     result = result.concat(setHiddenRecursive(element.children, element.collapsed || newHidden));
   }
 });
53207
 return result;
}
53210
function restoreVisibilityRecursive(elements, lastState) {
 var result = [];
 forEach$2(elements, function(element) {
   element.hidden = lastState[element.id];
53215
   result = result.concat(element);
53217
   if (element.children) {
     result = result.concat(restoreVisibilityRecursive(element.children, lastState));
   }
 });
53222
 return result;
}
53225
/**
* A handler that implements reversible attaching/detaching of shapes.
*/
function UpdateAttachmentHandler(modeling) {
 this._modeling = modeling;
}
53232
UpdateAttachmentHandler.$inject = [ 'modeling' ];
53234
53235
UpdateAttachmentHandler.prototype.execute = function(context) {
 var shape = context.shape,
     newHost = context.newHost,
     oldHost = shape.host;
53240
 // (0) detach from old host
 context.oldHost = oldHost;
 context.attacherIdx = removeAttacher(oldHost, shape);
53244
 // (1) attach to new host
 addAttacher(newHost, shape);
53247
 // (2) update host
 shape.host = newHost;
53250
 return shape;
};
53253
UpdateAttachmentHandler.prototype.revert = function(context) {
 var shape = context.shape,
     newHost = context.newHost,
     oldHost = context.oldHost,
     attacherIdx = context.attacherIdx;
53259
 // (2) update host
 shape.host = oldHost;
53262
 // (1) attach to new host
 removeAttacher(newHost, shape);
53265
 // (0) detach from old host
 addAttacher(oldHost, shape, attacherIdx);
53268
 return shape;
};
53271
53272
function removeAttacher(host, attacher) {
53274
 // remove attacher from host
 return remove(host && host.attachers, attacher);
}
53278
function addAttacher(host, attacher, idx) {
53280
 if (!host) {
   return;
 }
53284
 var attachers = host.attachers;
53286
 if (!attachers) {
   host.attachers = attachers = [];
 }
53290
 add(attachers, attacher, idx);
}
53293
function UpdateWaypointsHandler() { }
53295
UpdateWaypointsHandler.prototype.execute = function(context) {
53297
 var connection = context.connection,
     newWaypoints = context.newWaypoints;
53300
 context.oldWaypoints = connection.waypoints;
53302
 connection.waypoints = newWaypoints;
53304
 return connection;
};
53307
UpdateWaypointsHandler.prototype.revert = function(context) {
53309
 var connection = context.connection,
     oldWaypoints = context.oldWaypoints;
53312
 connection.waypoints = oldWaypoints;
53314
 return connection;
};
53317
/**
* The basic modeling entry point.
*
* @param {EventBus} eventBus
* @param {ElementFactory} elementFactory
* @param {CommandStack} commandStack
*/
function Modeling$1(eventBus, elementFactory, commandStack) {
 this._eventBus = eventBus;
 this._elementFactory = elementFactory;
 this._commandStack = commandStack;
53329
 var self = this;
53331
 eventBus.on('diagram.init', function() {
53333
   // register modeling handlers
   self.registerHandlers(commandStack);
 });
}
53338
Modeling$1.$inject = [ 'eventBus', 'elementFactory', 'commandStack' ];
53340
53341
Modeling$1.prototype.getHandlers = function() {
 return {
   'shape.append': AppendShapeHandler,
   'shape.create': CreateShapeHandler,
   'shape.delete': DeleteShapeHandler,
   'shape.move': MoveShapeHandler,
   'shape.resize': ResizeShapeHandler,
   'shape.replace': ReplaceShapeHandler,
   'shape.toggleCollapse': ToggleShapeCollapseHandler,
53351
   'spaceTool': SpaceToolHandler,
53353
   'label.create': CreateLabelHandler,
53355
   'connection.create': CreateConnectionHandler,
   'connection.delete': DeleteConnectionHandler,
   'connection.move': MoveConnectionHandler,
   'connection.layout': LayoutConnectionHandler,
53360
   'connection.updateWaypoints': UpdateWaypointsHandler,
53362
   'connection.reconnect': ReconnectConnectionHandler,
53364
   'elements.create': CreateElementsHandler,
   'elements.move': MoveElementsHandler,
   'elements.delete': DeleteElementsHandler,
53368
   'elements.distribute': DistributeElements,
   'elements.align': AlignElements,
53371
   'element.updateAttachment': UpdateAttachmentHandler
 };
};
53375
/**
* Register handlers with the command stack
*
* @param {CommandStack} commandStack
*/
Modeling$1.prototype.registerHandlers = function(commandStack) {
 forEach$2(this.getHandlers(), function(handler, id) {
   commandStack.registerHandler(id, handler);
 });
};
53386
53387
// modeling helpers //////////////////////
53389
Modeling$1.prototype.moveShape = function(shape, delta, newParent, newParentIndex, hints) {
53391
 if (typeof newParentIndex === 'object') {
   hints = newParentIndex;
   newParentIndex = null;
 }
53396
 var context = {
   shape: shape,
   delta:  delta,
   newParent: newParent,
   newParentIndex: newParentIndex,
   hints: hints || {}
 };
53404
 this._commandStack.execute('shape.move', context);
};
53407
53408
/**
* Update the attachment of the given shape.
*
* @param {djs.mode.Base} shape
* @param {djs.model.Base} [newHost]
*/
Modeling$1.prototype.updateAttachment = function(shape, newHost) {
 var context = {
   shape: shape,
   newHost: newHost
 };
53420
 this._commandStack.execute('element.updateAttachment', context);
};
53423
53424
/**
* Move a number of shapes to a new target, either setting it as
* the new parent or attaching it.
*
* @param {Array<djs.mode.Base>} shapes
* @param {Point} delta
* @param {djs.model.Base} [target]
* @param {Object} [hints]
* @param {boolean} [hints.attach=false]
*/
Modeling$1.prototype.moveElements = function(shapes, delta, target, hints) {
53436
 hints = hints || {};
53438
 var attach = hints.attach;
53440
 var newParent = target,
     newHost;
53443
 if (attach === true) {
   newHost = target;
   newParent = target.parent;
 } else
53448
 if (attach === false) {
   newHost = null;
 }
53452
 var context = {
   shapes: shapes,
   delta: delta,
   newParent: newParent,
   newHost: newHost,
   hints: hints
 };
53460
 this._commandStack.execute('elements.move', context);
};
53463
53464
Modeling$1.prototype.moveConnection = function(connection, delta, newParent, newParentIndex, hints) {
53466
 if (typeof newParentIndex === 'object') {
   hints = newParentIndex;
   newParentIndex = undefined;
 }
53471
 var context = {
   connection: connection,
   delta: delta,
   newParent: newParent,
   newParentIndex: newParentIndex,
   hints: hints || {}
 };
53479
 this._commandStack.execute('connection.move', context);
};
53482
53483
Modeling$1.prototype.layoutConnection = function(connection, hints) {
 var context = {
   connection: connection,
   hints: hints || {}
 };
53489
 this._commandStack.execute('connection.layout', context);
};
53492
53493
/**
* Create connection.
*
* @param {djs.model.Base} source
* @param {djs.model.Base} target
* @param {number} [parentIndex]
* @param {Object|djs.model.Connection} connection
* @param {djs.model.Base} parent
* @param {Object} hints
*
* @return {djs.model.Connection} the created connection.
*/
Modeling$1.prototype.createConnection = function(source, target, parentIndex, connection, parent, hints) {
53507
 if (typeof parentIndex === 'object') {
   hints = parent;
   parent = connection;
   connection = parentIndex;
   parentIndex = undefined;
 }
53514
 connection = this._create('connection', connection);
53516
 var context = {
   source: source,
   target: target,
   parent: parent,
   parentIndex: parentIndex,
   connection: connection,
   hints: hints
 };
53525
 this._commandStack.execute('connection.create', context);
53527
 return context.connection;
};
53530
53531
/**
* Create a shape at the specified position.
*
* @param {djs.model.Shape|Object} shape
* @param {Point} position
* @param {djs.model.Shape|djs.model.Root} target
* @param {number} [parentIndex] position in parents children list
* @param {Object} [hints]
* @param {boolean} [hints.attach] whether to attach to target or become a child
*
* @return {djs.model.Shape} the created shape
*/
Modeling$1.prototype.createShape = function(shape, position, target, parentIndex, hints) {
53545
 if (typeof parentIndex !== 'number') {
   hints = parentIndex;
   parentIndex = undefined;
 }
53550
 hints = hints || {};
53552
 var attach = hints.attach,
     parent,
     host;
53556
 shape = this._create('shape', shape);
53558
 if (attach) {
   parent = target.parent;
   host = target;
 } else {
   parent = target;
 }
53565
 var context = {
   position: position,
   shape: shape,
   parent: parent,
   parentIndex: parentIndex,
   host: host,
   hints: hints
 };
53574
 this._commandStack.execute('shape.create', context);
53576
 return context.shape;
};
53579
53580
Modeling$1.prototype.createElements = function(elements, position, parent, parentIndex, hints) {
 if (!isArray$4(elements)) {
   elements = [ elements ];
 }
53585
 if (typeof parentIndex !== 'number') {
   hints = parentIndex;
   parentIndex = undefined;
 }
53590
 hints = hints || {};
53592
 var context = {
   position: position,
   elements: elements,
   parent: parent,
   parentIndex: parentIndex,
   hints: hints
 };
53600
 this._commandStack.execute('elements.create', context);
53602
 return context.elements;
};
53605
53606
Modeling$1.prototype.createLabel = function(labelTarget, position, label, parent) {
53608
 label = this._create('label', label);
53610
 var context = {
   labelTarget: labelTarget,
   position: position,
   parent: parent || labelTarget.parent,
   shape: label
 };
53617
 this._commandStack.execute('label.create', context);
53619
 return context.shape;
};
53622
53623
/**
* Append shape to given source, drawing a connection
* between source and the newly created shape.
*
* @param {djs.model.Shape} source
* @param {djs.model.Shape|Object} shape
* @param {Point} position
* @param {djs.model.Shape} target
* @param {Object} [hints]
* @param {boolean} [hints.attach]
* @param {djs.model.Connection|Object} [hints.connection]
* @param {djs.model.Base} [hints.connectionParent]
*
* @return {djs.model.Shape} the newly created shape
*/
Modeling$1.prototype.appendShape = function(source, shape, position, target, hints) {
53640
 hints = hints || {};
53642
 shape = this._create('shape', shape);
53644
 var context = {
   source: source,
   position: position,
   target: target,
   shape: shape,
   connection: hints.connection,
   connectionParent: hints.connectionParent,
   hints: hints
 };
53654
 this._commandStack.execute('shape.append', context);
53656
 return context.shape;
};
53659
53660
Modeling$1.prototype.removeElements = function(elements) {
 var context = {
   elements: elements
 };
53665
 this._commandStack.execute('elements.delete', context);
};
53668
53669
Modeling$1.prototype.distributeElements = function(groups, axis, dimension) {
 var context = {
   groups: groups,
   axis: axis,
   dimension: dimension
 };
53676
 this._commandStack.execute('elements.distribute', context);
};
53679
53680
Modeling$1.prototype.removeShape = function(shape, hints) {
 var context = {
   shape: shape,
   hints: hints || {}
 };
53686
 this._commandStack.execute('shape.delete', context);
};
53689
53690
Modeling$1.prototype.removeConnection = function(connection, hints) {
 var context = {
   connection: connection,
   hints: hints || {}
 };
53696
 this._commandStack.execute('connection.delete', context);
};
53699
Modeling$1.prototype.replaceShape = function(oldShape, newShape, hints) {
 var context = {
   oldShape: oldShape,
   newData: newShape,
   hints: hints || {}
 };
53706
 this._commandStack.execute('shape.replace', context);
53708
 return context.newShape;
};
53711
Modeling$1.prototype.alignElements = function(elements, alignment) {
 var context = {
   elements: elements,
   alignment: alignment
 };
53717
 this._commandStack.execute('elements.align', context);
};
53720
Modeling$1.prototype.resizeShape = function(shape, newBounds, minBounds, hints) {
 var context = {
   shape: shape,
   newBounds: newBounds,
   minBounds: minBounds,
   hints: hints
 };
53728
 this._commandStack.execute('shape.resize', context);
};
53731
Modeling$1.prototype.createSpace = function(movingShapes, resizingShapes, delta, direction, start) {
 var context = {
   delta: delta,
   direction: direction,
   movingShapes: movingShapes,
   resizingShapes: resizingShapes,
   start: start
 };
53740
 this._commandStack.execute('spaceTool', context);
};
53743
Modeling$1.prototype.updateWaypoints = function(connection, newWaypoints, hints) {
 var context = {
   connection: connection,
   newWaypoints: newWaypoints,
   hints: hints || {}
 };
53750
 this._commandStack.execute('connection.updateWaypoints', context);
};
53753
Modeling$1.prototype.reconnect = function(connection, source, target, dockingOrPoints, hints) {
 var context = {
   connection: connection,
   newSource: source,
   newTarget: target,
   dockingOrPoints: dockingOrPoints,
   hints: hints || {}
 };
53762
 this._commandStack.execute('connection.reconnect', context);
};
53765
Modeling$1.prototype.reconnectStart = function(connection, newSource, dockingOrPoints, hints) {
 if (!hints) {
   hints = {};
 }
53770
 this.reconnect(connection, newSource, connection.target, dockingOrPoints, assign(hints, {
   docking: 'source'
 }));
};
53775
Modeling$1.prototype.reconnectEnd = function(connection, newTarget, dockingOrPoints, hints) {
 if (!hints) {
   hints = {};
 }
53780
 this.reconnect(connection, connection.source, newTarget, dockingOrPoints, assign(hints, {
   docking: 'target'
 }));
};
53785
Modeling$1.prototype.connect = function(source, target, attrs, hints) {
 return this.createConnection(source, target, attrs || {}, source.parent, hints);
};
53789
Modeling$1.prototype._create = function(type, attrs) {
 if (attrs instanceof Base$1) {
   return attrs;
 } else {
   return this._elementFactory.create(type, attrs);
 }
};
53797
Modeling$1.prototype.toggleCollapse = function(shape, hints) {
 var context = {
   shape: shape,
   hints: hints || {}
 };
53803
 this._commandStack.execute('shape.toggleCollapse', context);
};
53806
function UpdateModdlePropertiesHandler(elementRegistry) {
 this._elementRegistry = elementRegistry;
}
53810
UpdateModdlePropertiesHandler.$inject = ['elementRegistry'];
53812
UpdateModdlePropertiesHandler.prototype.execute = function(context) {
53814
 var element = context.element,
     moddleElement = context.moddleElement,
     properties = context.properties;
53818
 if (!moddleElement) {
   throw new Error('<moddleElement> required');
 }
53822
 var changed = context.changed || this.getVisualReferences(moddleElement).concat(element);
 var oldProperties = context.oldProperties || getModdleProperties(moddleElement, keys(properties));
53825
 setModdleProperties(moddleElement, properties);
53827
 context.oldProperties = oldProperties;
 context.changed = changed;
53830
 return changed;
};
53833
UpdateModdlePropertiesHandler.prototype.revert = function(context) {
 var oldProperties = context.oldProperties,
     moddleElement = context.moddleElement,
     changed = context.changed;
53838
 setModdleProperties(moddleElement, oldProperties);
53840
 return changed;
};
53843
/**
* Return visual references of given moddle element within the diagram.
*
* @param {ModdleElement} moddleElement
*
* @return {Array<djs.model.Element>}
*/
UpdateModdlePropertiesHandler.prototype.getVisualReferences = function(moddleElement) {
53852
 var elementRegistry = this._elementRegistry;
53854
 if (is$1(moddleElement, 'bpmn:DataObject')) {
   return getAllDataObjectReferences(moddleElement, elementRegistry);
 }
53858
 return [];
};
53861
53862
// helpers /////////////////
53864
function getModdleProperties(moddleElement, propertyNames) {
 return reduce(propertyNames, function(result, key) {
   result[key] = moddleElement.get(key);
   return result;
 }, {});
}
53871
function setModdleProperties(moddleElement, properties) {
 forEach$2(properties, function(value, key) {
   moddleElement.set(key, value);
 });
}
53877
function getAllDataObjectReferences(dataObject, elementRegistry) {
 return elementRegistry.filter(function(element) {
   return (
     is$1(element, 'bpmn:DataObjectReference') &&
         getBusinessObject(element).dataObjectRef === dataObject
   );
 });
}
53886
var DEFAULT_FLOW = 'default',
   ID = 'id',
   DI = 'di';
53890
var NULL_DIMENSIONS$1 = {
 width: 0,
 height: 0
};
53895
/**
* A handler that implements a BPMN 2.0 property update.
*
* This should be used to set simple properties on elements with
* an underlying BPMN business object.
*
* Use respective diagram-js provided handlers if you would
* like to perform automated modeling.
*/
function UpdatePropertiesHandler(
   elementRegistry, moddle, translate,
   modeling, textRenderer) {
53908
 this._elementRegistry = elementRegistry;
 this._moddle = moddle;
 this._translate = translate;
 this._modeling = modeling;
 this._textRenderer = textRenderer;
}
53915
UpdatePropertiesHandler.$inject = [
 'elementRegistry',
 'moddle',
 'translate',
 'modeling',
 'textRenderer'
];
53923
53924
// api //////////////////////
53926
/**
* Updates a BPMN element with a list of new properties
*
* @param {Object} context
* @param {djs.model.Base} context.element the element to update
* @param {Object} context.properties a list of properties to set on the element's
*                                    businessObject (the BPMN model element)
*
* @return {Array<djs.model.Base>} the updated element
*/
UpdatePropertiesHandler.prototype.execute = function(context) {
53938
 var element = context.element,
     changed = [ element ],
     translate = this._translate;
53942
 if (!element) {
   throw new Error(translate('element required'));
 }
53946
 var elementRegistry = this._elementRegistry,
     ids = this._moddle.ids;
53949
 var businessObject = element.businessObject,
     properties = unwrapBusinessObjects(context.properties),
     oldProperties = context.oldProperties || getProperties(element, properties);
53953
 if (isIdChange(properties, businessObject)) {
   ids.unclaim(businessObject[ID]);
53956
   elementRegistry.updateId(element, properties[ID]);
53958
   ids.claim(properties[ID], businessObject);
 }
53961
 // correctly indicate visual changes on default flow updates
 if (DEFAULT_FLOW in properties) {
53964
   if (properties[DEFAULT_FLOW]) {
     changed.push(elementRegistry.get(properties[DEFAULT_FLOW].id));
   }
53968
   if (businessObject[DEFAULT_FLOW]) {
     changed.push(elementRegistry.get(businessObject[DEFAULT_FLOW].id));
   }
 }
53973
 // update properties
 setProperties(element, properties);
53976
 // store old values
 context.oldProperties = oldProperties;
 context.changed = changed;
53980
 // indicate changed on objects affected by the update
 return changed;
};
53984
53985
UpdatePropertiesHandler.prototype.postExecute = function(context) {
 var element = context.element,
     label = element.label;
53989
 var text = label && getBusinessObject(label).name;
53991
 if (!text) {
   return;
 }
53995
 // get layouted text bounds and resize external
 // external label accordingly
 var newLabelBounds = this._textRenderer.getExternalLabelBounds(label, text);
53999
 this._modeling.resizeShape(label, newLabelBounds, NULL_DIMENSIONS$1);
};
54002
/**
* Reverts the update on a BPMN elements properties.
*
* @param  {Object} context
*
* @return {djs.model.Base} the updated element
*/
UpdatePropertiesHandler.prototype.revert = function(context) {
54011
 var element = context.element,
     properties = context.properties,
     oldProperties = context.oldProperties,
     businessObject = element.businessObject,
     elementRegistry = this._elementRegistry,
     ids = this._moddle.ids;
54018
 // update properties
 setProperties(element, oldProperties);
54021
 if (isIdChange(properties, businessObject)) {
   ids.unclaim(properties[ID]);
54024
   elementRegistry.updateId(element, oldProperties[ID]);
54026
   ids.claim(oldProperties[ID], businessObject);
 }
54029
 return context.changed;
};
54032
54033
function isIdChange(properties, businessObject) {
 return ID in properties && properties[ID] !== businessObject[ID];
}
54037
54038
function getProperties(element, properties) {
 var propertyNames = keys(properties),
     businessObject = element.businessObject,
     di = getDi(element);
54043
 return reduce(propertyNames, function(result, key) {
54045
   // handle DI separately
   if (key !== DI) {
     result[key] = businessObject.get(key);
54049
   } else {
     result[key] = getDiProperties(di, keys(properties.di));
   }
54053
   return result;
 }, {});
}
54057
54058
function getDiProperties(di, propertyNames) {
 return reduce(propertyNames, function(result, key) {
   result[key] = di && di.get(key);
54062
   return result;
 }, {});
}
54066
54067
function setProperties(element, properties) {
 var businessObject = element.businessObject,
     di = getDi(element);
54071
 forEach$2(properties, function(value, key) {
54073
   if (key !== DI) {
     businessObject.set(key, value);
   } else {
54077
     // only update, if di exists
     if (di) {
       setDiProperties(di, value);
     }
   }
 });
}
54085
54086
function setDiProperties(di, properties) {
 forEach$2(properties, function(value, key) {
   di.set(key, value);
 });
}
54092
54093
var referencePropertyNames = [ 'default' ];
54095
/**
* Make sure we unwrap the actual business object
* behind diagram element that may have been
* passed as arguments.
*
* @param  {Object} properties
*
* @return {Object} unwrappedProps
*/
function unwrapBusinessObjects(properties) {
54106
 var unwrappedProps = assign({}, properties);
54108
 referencePropertyNames.forEach(function(name) {
   if (name in properties) {
     unwrappedProps[name] = getBusinessObject(unwrappedProps[name]);
   }
 });
54114
 return unwrappedProps;
}
54117
function UpdateCanvasRootHandler(canvas, modeling) {
 this._canvas = canvas;
 this._modeling = modeling;
}
54122
UpdateCanvasRootHandler.$inject = [
 'canvas',
 'modeling'
];
54127
54128
UpdateCanvasRootHandler.prototype.execute = function(context) {
54130
 var canvas = this._canvas;
54132
 var newRoot = context.newRoot,
     newRootBusinessObject = newRoot.businessObject,
     oldRoot = canvas.getRootElement(),
     oldRootBusinessObject = oldRoot.businessObject,
     bpmnDefinitions = oldRootBusinessObject.$parent,
     diPlane = getDi(oldRoot);
54139
 // (1) replace process old <> new root
 canvas.setRootElement(newRoot);
 canvas.removeRootElement(oldRoot);
54143
 // (2) update root elements
 add(bpmnDefinitions.rootElements, newRootBusinessObject);
 newRootBusinessObject.$parent = bpmnDefinitions;
54147
 remove(bpmnDefinitions.rootElements, oldRootBusinessObject);
 oldRootBusinessObject.$parent = null;
54150
 // (3) wire di
 oldRoot.di = null;
54153
 diPlane.bpmnElement = newRootBusinessObject;
 newRoot.di = diPlane;
54156
 context.oldRoot = oldRoot;
54158
 // TODO(nikku): return changed elements?
 // return [ newRoot, oldRoot ];
};
54162
54163
UpdateCanvasRootHandler.prototype.revert = function(context) {
54165
 var canvas = this._canvas;
54167
 var newRoot = context.newRoot,
     newRootBusinessObject = newRoot.businessObject,
     oldRoot = context.oldRoot,
     oldRootBusinessObject = oldRoot.businessObject,
     bpmnDefinitions = newRootBusinessObject.$parent,
     diPlane = getDi(newRoot);
54174
 // (1) replace process old <> new root
 canvas.setRootElement(oldRoot);
 canvas.removeRootElement(newRoot);
54178
 // (2) update root elements
 remove(bpmnDefinitions.rootElements, newRootBusinessObject);
 newRootBusinessObject.$parent = null;
54182
 add(bpmnDefinitions.rootElements, oldRootBusinessObject);
 oldRootBusinessObject.$parent = bpmnDefinitions;
54185
 // (3) wire di
 newRoot.di = null;
54188
 diPlane.bpmnElement = oldRootBusinessObject;
 oldRoot.di = diPlane;
54191
 // TODO(nikku): return changed elements?
 // return [ newRoot, oldRoot ];
};
54195
/**
* A handler that allows us to add a new lane
* above or below an existing one.
*
* @param {Modeling} modeling
* @param {SpaceTool} spaceTool
*/
function AddLaneHandler(modeling, spaceTool) {
 this._modeling = modeling;
 this._spaceTool = spaceTool;
}
54207
AddLaneHandler.$inject = [
 'modeling',
 'spaceTool'
];
54212
54213
AddLaneHandler.prototype.preExecute = function(context) {
54215
 var spaceTool = this._spaceTool,
     modeling = this._modeling;
54218
 var shape = context.shape,
     location = context.location;
54221
 var lanesRoot = getLanesRoot(shape);
54223
 var isRoot = lanesRoot === shape,
     laneParent = isRoot ? shape : shape.parent;
54226
 var existingChildLanes = getChildLanes(laneParent);
54228
 // (0) add a lane if we currently got none and are adding to root
 if (!existingChildLanes.length) {
   modeling.createShape({ type: 'bpmn:Lane' }, {
     x: shape.x + LANE_INDENTATION,
     y: shape.y,
     width: shape.width - LANE_INDENTATION,
     height: shape.height
   }, laneParent);
 }
54238
 // (1) collect affected elements to create necessary space
 var allAffected = [];
54241
 eachElement(lanesRoot, function(element) {
   allAffected.push(element);
54244
   // handle element labels in the diagram root
   if (element.label) {
     allAffected.push(element.label);
   }
54249
   if (element === shape) {
     return [];
   }
54253
   return filter(element.children, function(c) {
     return c !== shape;
   });
 });
54258
 var offset = location === 'top' ? -120 : 120,
     lanePosition = location === 'top' ? shape.y : shape.y + shape.height,
     spacePos = lanePosition + (location === 'top' ? 10 : -10),
     direction = location === 'top' ? 'n' : 's';
54263
 var adjustments = spaceTool.calculateAdjustments(allAffected, 'y', offset, spacePos);
54265
 spaceTool.makeSpace(
   adjustments.movingShapes,
   adjustments.resizingShapes,
   { x: 0, y: offset },
   direction,
   spacePos
 );
54273
 // (2) create new lane at open space
 context.newLane = modeling.createShape({ type: 'bpmn:Lane' }, {
   x: shape.x + (isRoot ? LANE_INDENTATION : 0),
   y: lanePosition - (location === 'top' ? 120 : 0),
   width: shape.width - (isRoot ? LANE_INDENTATION : 0),
   height: 120
 }, laneParent);
};
54282
/**
* A handler that splits a lane into a number of sub-lanes,
* creating new sub lanes, if necessary.
*
* @param {Modeling} modeling
*/
function SplitLaneHandler(modeling, translate) {
 this._modeling = modeling;
 this._translate = translate;
}
54293
SplitLaneHandler.$inject = [
 'modeling',
 'translate'
];
54298
54299
SplitLaneHandler.prototype.preExecute = function(context) {
54301
 var modeling = this._modeling,
     translate = this._translate;
54304
 var shape = context.shape,
     newLanesCount = context.count;
54307
 var childLanes = getChildLanes(shape),
     existingLanesCount = childLanes.length;
54310
 if (existingLanesCount > newLanesCount) {
   throw new Error(translate('more than {count} child lanes', { count: newLanesCount }));
 }
54314
 var newLanesHeight = Math.round(shape.height / newLanesCount);
54316
 // Iterate from top to bottom in child lane order,
 // resizing existing lanes and creating new ones
 // so that they split the parent proportionally.
 //
 // Due to rounding related errors, the bottom lane
 // needs to take up all the remaining space.
 var laneY,
     laneHeight,
     laneBounds,
     newLaneAttrs,
     idx;
54328
 for (idx = 0; idx < newLanesCount; idx++) {
54330
   laneY = shape.y + idx * newLanesHeight;
54332
   // if bottom lane
   if (idx === newLanesCount - 1) {
     laneHeight = shape.height - (newLanesHeight * idx);
   } else {
     laneHeight = newLanesHeight;
   }
54339
   laneBounds = {
     x: shape.x + LANE_INDENTATION,
     y: laneY,
     width: shape.width - LANE_INDENTATION,
     height: laneHeight
   };
54346
   if (idx < existingLanesCount) {
54348
     // resize existing lane
     modeling.resizeShape(childLanes[idx], laneBounds);
   } else {
54352
     // create a new lane at position
     newLaneAttrs = {
       type: 'bpmn:Lane'
     };
54357
     modeling.createShape(newLaneAttrs, laneBounds, shape);
   }
 }
};
54362
/**
* A handler that resizes a lane.
*
* @param {Modeling} modeling
*/
function ResizeLaneHandler(modeling, spaceTool) {
 this._modeling = modeling;
 this._spaceTool = spaceTool;
}
54372
ResizeLaneHandler.$inject = [
 'modeling',
 'spaceTool'
];
54377
54378
ResizeLaneHandler.prototype.preExecute = function(context) {
54380
 var shape = context.shape,
     newBounds = context.newBounds,
     balanced = context.balanced;
54384
 if (balanced !== false) {
   this.resizeBalanced(shape, newBounds);
 } else {
   this.resizeSpace(shape, newBounds);
 }
};
54391
54392
/**
* Resize balanced, adjusting next / previous lane sizes.
*
* @param {djs.model.Shape} shape
* @param {Bounds} newBounds
*/
ResizeLaneHandler.prototype.resizeBalanced = function(shape, newBounds) {
54400
 var modeling = this._modeling;
54402
 var resizeNeeded = computeLanesResize(shape, newBounds);
54404
 // resize the lane
 modeling.resizeShape(shape, newBounds);
54407
 // resize other lanes as needed
 resizeNeeded.forEach(function(r) {
   modeling.resizeShape(r.shape, r.newBounds);
 });
};
54413
54414
/**
* Resize, making actual space and moving below / above elements.
*
* @param {djs.model.Shape} shape
* @param {Bounds} newBounds
*/
ResizeLaneHandler.prototype.resizeSpace = function(shape, newBounds) {
 var spaceTool = this._spaceTool;
54423
 var shapeTrbl = asTRBL(shape),
     newTrbl = asTRBL(newBounds);
54426
 var trblDiff = substractTRBL(newTrbl, shapeTrbl);
54428
 var lanesRoot = getLanesRoot(shape);
54430
 var allAffected = [],
     allLanes = [];
54433
 eachElement(lanesRoot, function(element) {
   allAffected.push(element);
54436
   if (is$1(element, 'bpmn:Lane') || is$1(element, 'bpmn:Participant')) {
     allLanes.push(element);
   }
54440
   return element.children;
 });
54443
 var change,
     spacePos,
     direction,
     offset,
     adjustments;
54449
 if (trblDiff.bottom || trblDiff.top) {
54451
   change = trblDiff.bottom || trblDiff.top;
   spacePos = shape.y + (trblDiff.bottom ? shape.height : 0) + (trblDiff.bottom ? -10 : 10);
   direction = trblDiff.bottom ? 's' : 'n';
54455
   offset = trblDiff.top > 0 || trblDiff.bottom < 0 ? -change : change;
54457
   adjustments = spaceTool.calculateAdjustments(allAffected, 'y', offset, spacePos);
54459
   spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: 0, y: change }, direction);
 }
54462
54463
 if (trblDiff.left || trblDiff.right) {
54465
   change = trblDiff.right || trblDiff.left;
   spacePos = shape.x + (trblDiff.right ? shape.width : 0) + (trblDiff.right ? -10 : 100);
   direction = trblDiff.right ? 'e' : 'w';
54469
   offset = trblDiff.left > 0 || trblDiff.right < 0 ? -change : change;
54471
   adjustments = spaceTool.calculateAdjustments(allLanes, 'x', offset, spacePos);
54473
   spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: change, y: 0 }, direction);
 }
};
54477
var FLOW_NODE_REFS_ATTR = 'flowNodeRef',
   LANES_ATTR = 'lanes';
54480
54481
/**
* A handler that updates lane refs on changed elements
*/
function UpdateFlowNodeRefsHandler(elementRegistry) {
 this._elementRegistry = elementRegistry;
}
54488
UpdateFlowNodeRefsHandler.$inject = [
 'elementRegistry'
];
54492
54493
UpdateFlowNodeRefsHandler.prototype.computeUpdates = function(flowNodeShapes, laneShapes) {
54495
 var handledNodes = [];
54497
 var updates = [];
54499
 var participantCache = {};
54501
 var allFlowNodeShapes = [];
54503
 function isInLaneShape(element, laneShape) {
54505
   var laneTrbl = asTRBL(laneShape);
54507
   var elementMid = {
     x: element.x + element.width / 2,
     y: element.y + element.height / 2
   };
54512
   return elementMid.x > laneTrbl.left &&
          elementMid.x < laneTrbl.right &&
          elementMid.y > laneTrbl.top &&
          elementMid.y < laneTrbl.bottom;
 }
54518
 function addFlowNodeShape(flowNodeShape) {
   if (handledNodes.indexOf(flowNodeShape) === -1) {
     allFlowNodeShapes.push(flowNodeShape);
     handledNodes.push(flowNodeShape);
   }
 }
54525
 function getAllLaneShapes(flowNodeShape) {
54527
   var root = getLanesRoot(flowNodeShape);
54529
   if (!participantCache[root.id]) {
     participantCache[root.id] = collectLanes(root);
   }
54533
   return participantCache[root.id];
 }
54536
 function getNewLanes(flowNodeShape) {
   if (!flowNodeShape.parent) {
     return [];
   }
54541
   var allLaneShapes = getAllLaneShapes(flowNodeShape);
54543
   return allLaneShapes.filter(function(l) {
     return isInLaneShape(flowNodeShape, l);
   }).map(function(shape) {
     return shape.businessObject;
   });
 }
54550
 laneShapes.forEach(function(laneShape) {
   var root = getLanesRoot(laneShape);
54553
   if (!root || handledNodes.indexOf(root) !== -1) {
     return;
   }
54557
   var children = root.children.filter(function(c) {
     return is$1(c, 'bpmn:FlowNode');
   });
54561
   children.forEach(addFlowNodeShape);
54563
   handledNodes.push(root);
 });
54566
 flowNodeShapes.forEach(addFlowNodeShape);
54568
54569
 allFlowNodeShapes.forEach(function(flowNodeShape) {
54571
   var flowNode = flowNodeShape.businessObject;
54573
   var lanes = flowNode.get(LANES_ATTR),
       remove = lanes.slice(),
       add = getNewLanes(flowNodeShape);
54577
   updates.push({ flowNode: flowNode, remove: remove, add: add });
 });
54580
 laneShapes.forEach(function(laneShape) {
54582
   var lane = laneShape.businessObject;
54584
   // lane got removed XX-)
   if (!laneShape.parent) {
     lane.get(FLOW_NODE_REFS_ATTR).forEach(function(flowNode) {
       updates.push({ flowNode: flowNode, remove: [ lane ], add: [] });
     });
   }
 });
54592
 return updates;
};
54595
UpdateFlowNodeRefsHandler.prototype.execute = function(context) {
54597
 var updates = context.updates;
54599
 if (!updates) {
   updates = context.updates = this.computeUpdates(context.flowNodeShapes, context.laneShapes);
 }
54603
54604
 updates.forEach(function(update) {
54606
   var flowNode = update.flowNode,
       lanes = flowNode.get(LANES_ATTR);
54609
   // unwire old
   update.remove.forEach(function(oldLane) {
     remove(lanes, oldLane);
     remove(oldLane.get(FLOW_NODE_REFS_ATTR), flowNode);
   });
54615
   // wire new
   update.add.forEach(function(newLane) {
     add(lanes, newLane);
     add(newLane.get(FLOW_NODE_REFS_ATTR), flowNode);
   });
 });
54622
 // TODO(nikku): return changed elements
 // return [ ... ];
};
54626
54627
UpdateFlowNodeRefsHandler.prototype.revert = function(context) {
54629
 var updates = context.updates;
54631
 updates.forEach(function(update) {
54633
   var flowNode = update.flowNode,
       lanes = flowNode.get(LANES_ATTR);
54636
   // unwire new
   update.add.forEach(function(newLane) {
     remove(lanes, newLane);
     remove(newLane.get(FLOW_NODE_REFS_ATTR), flowNode);
   });
54642
   // wire old
   update.remove.forEach(function(oldLane) {
     add(lanes, oldLane);
     add(oldLane.get(FLOW_NODE_REFS_ATTR), flowNode);
   });
 });
54649
 // TODO(nikku): return changed elements
 // return [ ... ];
};
54653
function IdClaimHandler(moddle) {
 this._moddle = moddle;
}
54657
IdClaimHandler.$inject = [ 'moddle' ];
54659
54660
IdClaimHandler.prototype.execute = function(context) {
 var ids = this._moddle.ids,
     id = context.id,
     element = context.element,
     claiming = context.claiming;
54666
 if (claiming) {
   ids.claim(id, element);
 } else {
   ids.unclaim(id);
 }
};
54673
/**
* Command revert implementation.
*/
IdClaimHandler.prototype.revert = function(context) {
 var ids = this._moddle.ids,
     id = context.id,
     element = context.element,
     claiming = context.claiming;
54682
 if (claiming) {
   ids.unclaim(id);
 } else {
   ids.claim(id, element);
 }
};
54689
var DEFAULT_COLORS = {
 fill: undefined,
 stroke: undefined
};
54694
54695
function SetColorHandler(commandStack) {
 this._commandStack = commandStack;
54698
 this._normalizeColor = function(color) {
54700
   // Remove color for falsy values.
   if (!color) {
     return undefined;
   }
54705
   if (isString(color)) {
     var hexColor = colorToHex(color);
54708
     if (hexColor) {
       return hexColor;
     }
   }
54713
   throw new Error('invalid color value: ' + color);
 };
}
54717
SetColorHandler.$inject = [
 'commandStack'
];
54721
54722
SetColorHandler.prototype.postExecute = function(context) {
 var elements = context.elements,
     colors = context.colors || DEFAULT_COLORS;
54726
 var self = this;
54728
 var di = {};
54730
 if ('fill' in colors) {
   assign(di, {
     'background-color': this._normalizeColor(colors.fill) });
 }
54735
 if ('stroke' in colors) {
   assign(di, {
     'border-color': this._normalizeColor(colors.stroke) });
 }
54740
 forEach$2(elements, function(element) {
   var assignedDi = isConnection$3(element) ? pick(di, [ 'border-color' ]) : di;
54743
   // TODO @barmac: remove once we drop bpmn.io properties
   ensureLegacySupport(assignedDi);
54746
   if (element.labelTarget) {
54748
     // set label colors as bpmndi:BPMNLabel#color
     self._commandStack.execute('element.updateModdleProperties', {
       element: element,
       moddleElement: getDi(element).label,
       properties: {
         color: di['background-color']
       }
     });
   } else {
54758
     // set colors bpmndi:BPMNEdge or bpmndi:BPMNShape
     self._commandStack.execute('element.updateProperties', {
       element: element,
       properties: {
         di: assignedDi
       }
     });
   }
 });
54768
};
54770
/**
* Convert color from rgb(a)/hsl to hex. Returns `null` for unknown color names and for colors
* with alpha less than 1.0. This depends on `<canvas>` serialization of the `context.fillStyle`.
* Cf. https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-fillstyle
*
* @example
* ```js
* var color = 'fuchsia';
* console.log(colorToHex(color));
* // "#ff00ff"
* color = 'rgba(1,2,3,0.4)';
* console.log(colorToHex(color));
* // null
* ```
*
* @param {string} color
* @returns {string|null}
*/
function colorToHex(color) {
 var context = document.createElement('canvas').getContext('2d');
54791
 // (0) Start with transparent to account for browser default values.
 context.fillStyle = 'transparent';
54794
 // (1) Assign color so that it's serialized.
 context.fillStyle = color;
54797
 // (2) Return null for non-hex serialization result.
 return /^#[0-9a-fA-F]{6}$/.test(context.fillStyle) ? context.fillStyle : null;
}
54801
function isConnection$3(element) {
 return !!element.waypoints;
}
54805
/**
* Add legacy properties if required.
* @param {{ 'border-color': string?, 'background-color': string? }} di
*/
function ensureLegacySupport(di) {
 if ('border-color' in di) {
   di.stroke = di['border-color'];
 }
54814
 if ('background-color' in di) {
   di.fill = di['background-color'];
 }
}
54819
var NULL_DIMENSIONS = {
 width: 0,
 height: 0
};
54824
54825
/**
* A handler that updates the text of a BPMN element.
*/
function UpdateLabelHandler(modeling, textRenderer, bpmnFactory) {
54830
 /**
  * Creates an empty `diLabel` attribute for embedded labels.
  *
  * @param {djs.model.Base} element
  * @param {string} text
  */
 function ensureInternalLabelDi(element, text) {
   if (isLabelExternal(element)) {
     return;
   }
54841
   var di = getDi(element);
54843
   if (text && !di.label) {
     di.label = bpmnFactory.create('bpmndi:BPMNLabel');
   }
54847
   if (!text && di.label) {
     delete di.label;
   }
 }
54852
54853
 /**
  * Set the label and return the changed elements.
  *
  * Element parameter can be label itself or connection (i.e. sequence flow).
  *
  * @param {djs.model.Base} element
  * @param {string} text
  */
 function setText(element, text) {
54863
   // external label if present
   var label = element.label || element;
54866
   var labelTarget = element.labelTarget || element;
54868
   setLabel(label, text);
54870
   ensureInternalLabelDi(element, text);
54872
   return [ label, labelTarget ];
 }
54875
 function preExecute(ctx) {
   var element = ctx.element,
       businessObject = element.businessObject,
       newLabel = ctx.newLabel;
54880
   if (!isLabel$6(element)
       && isLabelExternal(element)
       && !hasExternalLabel(element)
       && !isEmptyText(newLabel)) {
54885
     // create label
     var paddingTop = 7;
54888
     var labelCenter = getExternalLabelMid(element);
54890
     labelCenter = {
       x: labelCenter.x,
       y: labelCenter.y + paddingTop
     };
54895
     modeling.createLabel(element, labelCenter, {
       id: businessObject.id + '_label',
       businessObject: businessObject,
       di: element.di
     });
   }
 }
54903
 function execute(ctx) {
   ctx.oldLabel = getLabel(ctx.element);
   return setText(ctx.element, ctx.newLabel);
 }
54908
 function revert(ctx) {
   return setText(ctx.element, ctx.oldLabel);
 }
54912
 function postExecute(ctx) {
   var element = ctx.element,
       label = element.label || element,
       newLabel = ctx.newLabel,
       newBounds = ctx.newBounds,
       hints = ctx.hints || {};
54919
   // ignore internal labels for elements except text annotations
   if (!isLabel$6(label) && !is$1(label, 'bpmn:TextAnnotation')) {
     return;
   }
54924
   if (isLabel$6(label) && isEmptyText(newLabel)) {
54926
     if (hints.removeShape !== false) {
       modeling.removeShape(label, { unsetLabel: false });
     }
54930
     return;
   }
54933
   var text = getLabel(label);
54935
   // resize element based on label _or_ pre-defined bounds
   if (typeof newBounds === 'undefined') {
     newBounds = textRenderer.getExternalLabelBounds(label, text);
   }
54940
   // setting newBounds to false or _null_ will
   // disable the postExecute resize operation
   if (newBounds) {
     modeling.resizeShape(label, newBounds, NULL_DIMENSIONS);
   }
 }
54947
 // API
54949
 this.preExecute = preExecute;
 this.execute = execute;
 this.revert = revert;
 this.postExecute = postExecute;
}
54955
UpdateLabelHandler.$inject = [
 'modeling',
 'textRenderer',
 'bpmnFactory'
];
54961
54962
// helpers ///////////////////////
54964
function isEmptyText(label) {
 return !label || !label.trim();
}
54968
/**
* BPMN 2.0 modeling features activator
*
* @param {EventBus} eventBus
* @param {ElementFactory} elementFactory
* @param {CommandStack} commandStack
* @param {BpmnRules} bpmnRules
*/
function Modeling(
   eventBus, elementFactory, commandStack,
   bpmnRules) {
54980
 Modeling$1.call(this, eventBus, elementFactory, commandStack);
54982
 this._bpmnRules = bpmnRules;
}
54985
inherits$1(Modeling, Modeling$1);
54987
Modeling.$inject = [
 'eventBus',
 'elementFactory',
 'commandStack',
 'bpmnRules'
];
54994
54995
Modeling.prototype.getHandlers = function() {
 var handlers = Modeling$1.prototype.getHandlers.call(this);
54998
 handlers['element.updateModdleProperties'] = UpdateModdlePropertiesHandler;
 handlers['element.updateProperties'] = UpdatePropertiesHandler;
 handlers['canvas.updateRoot'] = UpdateCanvasRootHandler;
 handlers['lane.add'] = AddLaneHandler;
 handlers['lane.resize'] = ResizeLaneHandler;
 handlers['lane.split'] = SplitLaneHandler;
 handlers['lane.updateRefs'] = UpdateFlowNodeRefsHandler;
 handlers['id.updateClaim'] = IdClaimHandler;
 handlers['element.setColor'] = SetColorHandler;
 handlers['element.updateLabel'] = UpdateLabelHandler;
55009
 return handlers;
};
55012
55013
Modeling.prototype.updateLabel = function(element, newLabel, newBounds, hints) {
 this._commandStack.execute('element.updateLabel', {
   element: element,
   newLabel: newLabel,
   newBounds: newBounds,
   hints: hints || {}
 });
};
55022
55023
Modeling.prototype.connect = function(source, target, attrs, hints) {
55025
 var bpmnRules = this._bpmnRules;
55027
 if (!attrs) {
   attrs = bpmnRules.canConnect(source, target);
 }
55031
 if (!attrs) {
   return;
 }
55035
 return this.createConnection(source, target, attrs, source.parent, hints);
};
55038
55039
Modeling.prototype.updateModdleProperties = function(element, moddleElement, properties) {
 this._commandStack.execute('element.updateModdleProperties', {
   element: element,
   moddleElement: moddleElement,
   properties: properties
 });
};
55047
Modeling.prototype.updateProperties = function(element, properties) {
 this._commandStack.execute('element.updateProperties', {
   element: element,
   properties: properties
 });
};
55054
Modeling.prototype.resizeLane = function(laneShape, newBounds, balanced) {
 this._commandStack.execute('lane.resize', {
   shape: laneShape,
   newBounds: newBounds,
   balanced: balanced
 });
};
55062
Modeling.prototype.addLane = function(targetLaneShape, location) {
 var context = {
   shape: targetLaneShape,
   location: location
 };
55068
 this._commandStack.execute('lane.add', context);
55070
 return context.newLane;
};
55073
Modeling.prototype.splitLane = function(targetLane, count) {
 this._commandStack.execute('lane.split', {
   shape: targetLane,
   count: count
 });
};
55080
/**
* Transform the current diagram into a collaboration.
*
* @return {djs.model.Root} the new root element
*/
Modeling.prototype.makeCollaboration = function() {
55087
 var collaborationElement = this._create('root', {
   type: 'bpmn:Collaboration'
 });
55091
 var context = {
   newRoot: collaborationElement
 };
55095
 this._commandStack.execute('canvas.updateRoot', context);
55097
 return collaborationElement;
};
55100
Modeling.prototype.updateLaneRefs = function(flowNodeShapes, laneShapes) {
55102
 this._commandStack.execute('lane.updateRefs', {
   flowNodeShapes: flowNodeShapes,
   laneShapes: laneShapes
 });
};
55108
/**
* Transform the current diagram into a process.
*
* @return {djs.model.Root} the new root element
*/
Modeling.prototype.makeProcess = function() {
55115
 var processElement = this._create('root', {
   type: 'bpmn:Process'
 });
55119
 var context = {
   newRoot: processElement
 };
55123
 this._commandStack.execute('canvas.updateRoot', context);
};
55126
55127
Modeling.prototype.claimId = function(id, moddleElement) {
 this._commandStack.execute('id.updateClaim', {
   id: id,
   element: moddleElement,
   claiming: true
 });
};
55135
55136
Modeling.prototype.unclaimId = function(id, moddleElement) {
 this._commandStack.execute('id.updateClaim', {
   id: id,
   element: moddleElement
 });
};
55143
Modeling.prototype.setColor = function(elements, colors) {
 if (!elements.length) {
   elements = [ elements ];
 }
55148
 this._commandStack.execute('element.setColor', {
   elements: elements,
   colors: colors
 });
};
55154
/**
* A base connection layouter implementation
* that layouts the connection by directly connecting
* mid(source) + mid(target).
*/
function BaseLayouter() {}
55161
55162
/**
* Return the new layouted waypoints for the given connection.
*
* The connection passed is still unchanged; you may figure out about
* the new connection start / end via the layout hints provided.
*
* @param {djs.model.Connection} connection
* @param {Object} [hints]
* @param {Point} [hints.connectionStart]
* @param {Point} [hints.connectionEnd]
* @param {Point} [hints.source]
* @param {Point} [hints.target]
*
* @return {Array<Point>} the layouted connection waypoints
*/
BaseLayouter.prototype.layoutConnection = function(connection, hints) {
55179
 hints = hints || {};
55181
 return [
   hints.connectionStart || getMid(hints.source || connection.source),
   hints.connectionEnd || getMid(hints.target || connection.target)
 ];
};
55187
var MIN_SEGMENT_LENGTH = 20,
   POINT_ORIENTATION_PADDING = 5;
55190
var round$1 = Math.round;
55192
var INTERSECTION_THRESHOLD = 20,
   ORIENTATION_THRESHOLD = {
     'h:h': 20,
     'v:v': 20,
     'h:v': -10,
     'v:h': -10
   };
55200
function needsTurn(orientation, startDirection) {
 return !{
   t: /top/,
   r: /right/,
   b: /bottom/,
   l: /left/,
   h: /./,
   v: /./
 }[startDirection].test(orientation);
}
55211
function canLayoutStraight(direction, targetOrientation) {
 return {
   t: /top/,
   r: /right/,
   b: /bottom/,
   l: /left/,
   h: /left|right/,
   v: /top|bottom/
 }[direction].test(targetOrientation);
}
55222
function getSegmentBendpoints(a, b, directions) {
 var orientation = getOrientation(b, a, POINT_ORIENTATION_PADDING);
55225
 var startDirection = directions.split(':')[0];
55227
 var xmid = round$1((b.x - a.x) / 2 + a.x),
     ymid = round$1((b.y - a.y) / 2 + a.y);
55230
 var segmentEnd, segmentDirections;
55232
 var layoutStraight = canLayoutStraight(startDirection, orientation),
     layoutHorizontal = /h|r|l/.test(startDirection),
     layoutTurn = false;
55236
 var turnNextDirections = false;
55238
 if (layoutStraight) {
   segmentEnd = layoutHorizontal ? { x: xmid, y: a.y } : { x: a.x, y: ymid };
55241
   segmentDirections = layoutHorizontal ? 'h:h' : 'v:v';
 } else {
   layoutTurn = needsTurn(orientation, startDirection);
55245
   segmentDirections = layoutHorizontal ? 'h:v' : 'v:h';
55247
   if (layoutTurn) {
55249
     if (layoutHorizontal) {
       turnNextDirections = ymid === a.y;
55252
       segmentEnd = {
         x: a.x + MIN_SEGMENT_LENGTH * (/l/.test(startDirection) ? -1 : 1),
         y: turnNextDirections ? ymid + MIN_SEGMENT_LENGTH : ymid
       };
     } else {
       turnNextDirections = xmid === a.x;
55259
       segmentEnd = {
         x: turnNextDirections ? xmid + MIN_SEGMENT_LENGTH : xmid,
         y: a.y + MIN_SEGMENT_LENGTH * (/t/.test(startDirection) ? -1 : 1)
       };
     }
55265
   } else {
     segmentEnd = {
       x: xmid,
       y: ymid
     };
   }
 }
55273
 return {
   waypoints: getBendpoints(a, segmentEnd, segmentDirections).concat(segmentEnd),
   directions:  segmentDirections,
   turnNextDirections: turnNextDirections
 };
}
55280
function getStartSegment(a, b, directions) {
 return getSegmentBendpoints(a, b, directions);
}
55284
function getEndSegment(a, b, directions) {
 var invertedSegment = getSegmentBendpoints(b, a, invertDirections(directions));
55287
 return {
   waypoints: invertedSegment.waypoints.slice().reverse(),
   directions: invertDirections(invertedSegment.directions),
   turnNextDirections: invertedSegment.turnNextDirections
 };
}
55294
function getMidSegment(startSegment, endSegment) {
55296
 var startDirection = startSegment.directions.split(':')[1],
     endDirection = endSegment.directions.split(':')[0];
55299
 if (startSegment.turnNextDirections) {
   startDirection = startDirection == 'h' ? 'v' : 'h';
 }
55303
 if (endSegment.turnNextDirections) {
   endDirection = endDirection == 'h' ? 'v' : 'h';
 }
55307
 var directions = startDirection + ':' + endDirection;
55309
 var bendpoints = getBendpoints(
   startSegment.waypoints[startSegment.waypoints.length - 1],
   endSegment.waypoints[0],
   directions
 );
55315
 return {
   waypoints: bendpoints,
   directions: directions
 };
}
55321
function invertDirections(directions) {
 return directions.split(':').reverse().join(':');
}
55325
/**
* Handle simple layouts with maximum two bendpoints.
*/
function getSimpleBendpoints(a, b, directions) {
55330
 var xmid = round$1((b.x - a.x) / 2 + a.x),
     ymid = round$1((b.y - a.y) / 2 + a.y);
55333
 // one point, right or left from a
 if (directions === 'h:v') {
   return [ { x: b.x, y: a.y } ];
 }
55338
 // one point, above or below a
 if (directions === 'v:h') {
   return [ { x: a.x, y: b.y } ];
 }
55343
 // vertical segment between a and b
 if (directions === 'h:h') {
   return [
     { x: xmid, y: a.y },
     { x: xmid, y: b.y }
   ];
 }
55351
 // horizontal segment between a and b
 if (directions === 'v:v') {
   return [
     { x: a.x, y: ymid },
     { x: b.x, y: ymid }
   ];
 }
55359
 throw new Error('invalid directions: can only handle varians of [hv]:[hv]');
}
55362
55363
/**
* Returns the mid points for a manhattan connection between two points.
*
* @example h:h (horizontal:horizontal)
*
* [a]----[x]
*         |
*        [x]----[b]
*
* @example h:v (horizontal:vertical)
*
* [a]----[x]
*         |
*        [b]
*
* @example h:r (horizontal:right)
*
* [a]----[x]
*         |
*    [b]-[x]
*
* @param  {Point} a
* @param  {Point} b
* @param  {string} directions
*
* @return {Array<Point>}
*/
function getBendpoints(a, b, directions) {
 directions = directions || 'h:h';
55393
 if (!isValidDirections(directions)) {
   throw new Error(
     'unknown directions: <' + directions + '>: ' +
     'must be specified as <start>:<end> ' +
     'with start/end in { h,v,t,r,b,l }'
   );
 }
55401
 // compute explicit directions, involving trbl dockings
 // using a three segmented layouting algorithm
 if (isExplicitDirections(directions)) {
   var startSegment = getStartSegment(a, b, directions),
       endSegment = getEndSegment(a, b, directions),
       midSegment = getMidSegment(startSegment, endSegment);
55408
   return [].concat(
     startSegment.waypoints,
     midSegment.waypoints,
     endSegment.waypoints
   );
 }
55415
 // handle simple [hv]:[hv] cases that can be easily computed
 return getSimpleBendpoints(a, b, directions);
}
55419
/**
* Create a connection between the two points according
* to the manhattan layout (only horizontal and vertical) edges.
*
* @param {Point} a
* @param {Point} b
*
* @param {string} [directions='h:h'] specifies manhattan directions for each point as {adirection}:{bdirection}.
                  A directionfor a point is either `h` (horizontal) or `v` (vertical)
*
* @return {Array<Point>}
*/
function connectPoints(a, b, directions) {
55433
 var points = getBendpoints(a, b, directions);
55435
 points.unshift(a);
 points.push(b);
55438
 return withoutRedundantPoints(points);
}
55441
55442
/**
* Connect two rectangles using a manhattan layouted connection.
*
* @param {Bounds} source source rectangle
* @param {Bounds} target target rectangle
* @param {Point} [start] source docking
* @param {Point} [end] target docking
*
* @param {Object} [hints]
* @param {string} [hints.preserveDocking=source] preserve docking on selected side
* @param {Array<string>} [hints.preferredLayouts]
* @param {Point|boolean} [hints.connectionStart] whether the start changed
* @param {Point|boolean} [hints.connectionEnd] whether the end changed
*
* @return {Array<Point>} connection points
*/
function connectRectangles(source, target, start, end, hints) {
55460
 var preferredLayouts = hints && hints.preferredLayouts || [];
55462
 var preferredLayout = without(preferredLayouts, 'straight')[0] || 'h:h';
55464
 var threshold = ORIENTATION_THRESHOLD[preferredLayout] || 0;
55466
 var orientation = getOrientation(source, target, threshold);
55468
 var directions = getDirections(orientation, preferredLayout);
55470
 start = start || getMid(source);
 end = end || getMid(target);
55473
 var directionSplit = directions.split(':');
55475
 // compute actual docking points for start / end
 // this ensures we properly layout only parts of the
 // connection that lies in between the two rectangles
 var startDocking = getDockingPoint(start, source, directionSplit[0], invertOrientation(orientation)),
     endDocking = getDockingPoint(end, target, directionSplit[1], orientation);
55481
 return connectPoints(startDocking, endDocking, directions);
}
55484
55485
/**
* Repair the connection between two rectangles, of which one has been updated.
*
* @param {Bounds} source
* @param {Bounds} target
* @param {Point} [start]
* @param {Point} [end]
* @param {Array<Point>} [waypoints]
* @param {Object} [hints]
* @param {Array<string>} [hints.preferredLayouts] list of preferred layouts
* @param {boolean} [hints.connectionStart]
* @param {boolean} [hints.connectionEnd]
*
* @return {Array<Point>} repaired waypoints
*/
function repairConnection(source, target, start, end, waypoints, hints) {
55502
 if (isArray$4(start)) {
   waypoints = start;
   hints = end;
55506
   start = getMid(source);
   end = getMid(target);
 }
55510
 hints = assign({ preferredLayouts: [] }, hints);
 waypoints = waypoints || [];
55513
 var preferredLayouts = hints.preferredLayouts,
     preferStraight = preferredLayouts.indexOf('straight') !== -1,
     repairedWaypoints;
55517
 // just layout non-existing or simple connections
 // attempt to render straight lines, if required
55520
 // attempt to layout a straight line
 repairedWaypoints = preferStraight && tryLayoutStraight(source, target, start, end, hints);
55523
 if (repairedWaypoints) {
   return repairedWaypoints;
 }
55527
 // try to layout from end
 repairedWaypoints = hints.connectionEnd && tryRepairConnectionEnd(target, source, end, waypoints);
55530
 if (repairedWaypoints) {
   return repairedWaypoints;
 }
55534
 // try to layout from start
 repairedWaypoints = hints.connectionStart && tryRepairConnectionStart(source, target, start, waypoints);
55537
 if (repairedWaypoints) {
   return repairedWaypoints;
 }
55541
 // or whether nothing seems to have changed
 if (!hints.connectionStart && !hints.connectionEnd && waypoints && waypoints.length) {
   return waypoints;
 }
55546
 // simply reconnect if nothing else worked
 return connectRectangles(source, target, start, end, hints);
}
55550
55551
function inRange(a, start, end) {
 return a >= start && a <= end;
}
55555
function isInRange(axis, a, b) {
 var size = {
   x: 'width',
   y: 'height'
 };
55561
 return inRange(a[axis], b[axis], b[axis] + b[size[axis]]);
}
55564
/**
* Layout a straight connection
*
* @param {Bounds} source
* @param {Bounds} target
* @param {Point} start
* @param {Point} end
* @param {Object} [hints]
*
* @return {Array<Point>|null} waypoints if straight layout worked
*/
function tryLayoutStraight(source, target, start, end, hints) {
 var axis = {},
     primaryAxis,
     orientation;
55580
 orientation = getOrientation(source, target);
55582
 // only layout a straight connection if shapes are
 // horizontally or vertically aligned
 if (!/^(top|bottom|left|right)$/.test(orientation)) {
   return null;
 }
55588
 if (/top|bottom/.test(orientation)) {
   primaryAxis = 'x';
 }
55592
 if (/left|right/.test(orientation)) {
   primaryAxis = 'y';
 }
55596
 if (hints.preserveDocking === 'target') {
55598
   if (!isInRange(primaryAxis, end, source)) {
     return null;
   }
55602
   axis[primaryAxis] = end[primaryAxis];
55604
   return [
     {
       x: axis.x !== undefined ? axis.x : start.x,
       y: axis.y !== undefined ? axis.y : start.y,
       original: {
         x: axis.x !== undefined ? axis.x : start.x,
         y: axis.y !== undefined ? axis.y : start.y
       }
     },
     {
       x: end.x,
       y: end.y
     }
   ];
55619
 } else {
55621
   if (!isInRange(primaryAxis, start, target)) {
     return null;
   }
55625
   axis[primaryAxis] = start[primaryAxis];
55627
   return [
     {
       x: start.x,
       y: start.y
     },
     {
       x: axis.x !== undefined ? axis.x : end.x,
       y: axis.y !== undefined ? axis.y : end.y,
       original: {
         x: axis.x !== undefined ? axis.x : end.x,
         y: axis.y !== undefined ? axis.y : end.y
       }
     }
   ];
 }
55643
}
55645
/**
* Repair a connection from start.
*
* @param {Bounds} moved
* @param {Bounds} other
* @param {Point} newDocking
* @param {Array<Point>} points originalPoints from moved to other
*
* @return {Array<Point>|null} the repaired points between the two rectangles
*/
function tryRepairConnectionStart(moved, other, newDocking, points) {
 return _tryRepairConnectionSide(moved, other, newDocking, points);
}
55659
/**
* Repair a connection from end.
*
* @param {Bounds} moved
* @param {Bounds} other
* @param {Point} newDocking
* @param {Array<Point>} points originalPoints from moved to other
*
* @return {Array<Point>|null} the repaired points between the two rectangles
*/
function tryRepairConnectionEnd(moved, other, newDocking, points) {
 var waypoints = points.slice().reverse();
55672
 waypoints = _tryRepairConnectionSide(moved, other, newDocking, waypoints);
55674
 return waypoints ? waypoints.reverse() : null;
}
55677
/**
* Repair a connection from one side that moved.
*
* @param {Bounds} moved
* @param {Bounds} other
* @param {Point} newDocking
* @param {Array<Point>} points originalPoints from moved to other
*
* @return {Array<Point>} the repaired points between the two rectangles
*/
function _tryRepairConnectionSide(moved, other, newDocking, points) {
55689
 function needsRelayout(points) {
   if (points.length < 3) {
     return true;
   }
55694
   if (points.length > 4) {
     return false;
   }
55698
   // relayout if two points overlap
   // this is most likely due to
   return !!find(points, function(p, idx) {
     var q = points[idx - 1];
55703
     return q && pointDistance(p, q) < 3;
   });
 }
55707
 function repairBendpoint(candidate, oldPeer, newPeer) {
55709
   var alignment = pointsAligned(oldPeer, candidate);
55711
   switch (alignment) {
   case 'v':
55714
     // repair horizontal alignment
     return { x: newPeer.x, y: candidate.y };
   case 'h':
55718
     // repair vertical alignment
     return { x: candidate.x, y: newPeer.y };
   }
55722
   return { x: candidate.x, y: candidate. y };
 }
55725
 function removeOverlapping(points, a, b) {
   var i;
55728
   for (i = points.length - 2; i !== 0; i--) {
55730
     // intersects (?) break, remove all bendpoints up to this one and relayout
     if (pointInRect(points[i], a, INTERSECTION_THRESHOLD) ||
         pointInRect(points[i], b, INTERSECTION_THRESHOLD)) {
55734
       // return sliced old connection
       return points.slice(i);
     }
   }
55739
   return points;
 }
55742
 // (0) only repair what has layoutable bendpoints
55744
 // (1) if only one bendpoint and on shape moved onto other shapes axis
 //     (horizontally / vertically), relayout
55747
 if (needsRelayout(points)) {
   return null;
 }
55751
 var oldDocking = points[0],
     newPoints = points.slice(),
     slicedPoints;
55755
 // (2) repair only last line segment and only if it was layouted before
55757
 newPoints[0] = newDocking;
 newPoints[1] = repairBendpoint(newPoints[1], oldDocking, newDocking);
55760
55761
 // (3) if shape intersects with any bendpoint after repair,
 //     remove all segments up to this bendpoint and repair from there
 slicedPoints = removeOverlapping(newPoints, moved, other);
55765
 if (slicedPoints !== newPoints) {
   newPoints = _tryRepairConnectionSide(moved, other, newDocking, slicedPoints);
 }
55769
 // (4) do NOT repair if repaired bendpoints are aligned
 if (newPoints && pointsAligned(newPoints)) {
   return null;
 }
55774
 return newPoints;
}
55777
55778
/**
* Returns the manhattan directions connecting two rectangles
* with the given orientation.
*
* Will always return the default layout, if it is specific
* regarding sides already (trbl).
*
* @example
*
* getDirections('top'); // -> 'v:v'
* getDirections('intersect'); // -> 't:t'
*
* getDirections('top-right', 'v:h'); // -> 'v:h'
* getDirections('top-right', 'h:h'); // -> 'h:h'
*
*
* @param {string} orientation
* @param {string} defaultLayout
*
* @return {string}
*/
function getDirections(orientation, defaultLayout) {
55801
 // don't override specific trbl directions
 if (isExplicitDirections(defaultLayout)) {
   return defaultLayout;
 }
55806
 switch (orientation) {
 case 'intersect':
   return 't:t';
55810
 case 'top':
 case 'bottom':
   return 'v:v';
55814
 case 'left':
 case 'right':
   return 'h:h';
55818
 // 'top-left'
 // 'top-right'
 // 'bottom-left'
 // 'bottom-right'
 default:
   return defaultLayout;
 }
}
55827
function isValidDirections(directions) {
 return directions && /^h|v|t|r|b|l:h|v|t|r|b|l$/.test(directions);
}
55831
function isExplicitDirections(directions) {
 return directions && /t|r|b|l/.test(directions);
}
55835
function invertOrientation(orientation) {
 return {
   'top': 'bottom',
   'bottom': 'top',
   'left': 'right',
   'right': 'left',
   'top-left': 'bottom-right',
   'bottom-right': 'top-left',
   'top-right': 'bottom-left',
   'bottom-left': 'top-right',
 }[orientation];
}
55848
function getDockingPoint(point, rectangle, dockingDirection, targetOrientation) {
55850
 // ensure we end up with a specific docking direction
 // based on the targetOrientation, if <h|v> is being passed
55853
 if (dockingDirection === 'h') {
   dockingDirection = /left/.test(targetOrientation) ? 'l' : 'r';
 }
55857
 if (dockingDirection === 'v') {
   dockingDirection = /top/.test(targetOrientation) ? 't' : 'b';
 }
55861
 if (dockingDirection === 't') {
   return { original: point, x: point.x, y: rectangle.y };
 }
55865
 if (dockingDirection === 'r') {
   return { original: point, x: rectangle.x + rectangle.width, y: point.y };
 }
55869
 if (dockingDirection === 'b') {
   return { original: point, x: point.x, y: rectangle.y + rectangle.height };
 }
55873
 if (dockingDirection === 'l') {
   return { original: point, x: rectangle.x, y: point.y };
 }
55877
 throw new Error('unexpected dockingDirection: <' + dockingDirection + '>');
}
55880
55881
/**
* Return list of waypoints with redundant ones filtered out.
*
* @example
*
* Original points:
*
*   [x] ----- [x] ------ [x]
*                         |
*                        [x] ----- [x] - [x]
*
* Filtered:
*
*   [x] ---------------- [x]
*                         |
*                        [x] ----------- [x]
*
* @param  {Array<Point>} waypoints
*
* @return {Array<Point>}
*/
function withoutRedundantPoints(waypoints) {
 return waypoints.reduce(function(points, p, idx) {
55905
   var previous = points[points.length - 1],
       next = waypoints[idx + 1];
55908
   if (!pointsOnLine(previous, next, p, 0)) {
     points.push(p);
   }
55912
   return points;
 }, []);
}
55916
var ATTACH_ORIENTATION_PADDING = -10,
   BOUNDARY_TO_HOST_THRESHOLD$1 = 40;
55919
var oppositeOrientationMapping = {
 'top': 'bottom',
 'top-right': 'bottom-left',
 'top-left': 'bottom-right',
 'right': 'left',
 'bottom': 'top',
 'bottom-right': 'top-left',
 'bottom-left': 'top-right',
 'left': 'right'
};
55930
var orientationDirectionMapping = {
 top: 't',
 right: 'r',
 bottom: 'b',
 left: 'l'
};
55937
55938
function BpmnLayouter() {}
55940
inherits$1(BpmnLayouter, BaseLayouter);
55942
55943
BpmnLayouter.prototype.layoutConnection = function(connection, hints) {
 if (!hints) {
   hints = {};
 }
55948
 var source = hints.source || connection.source,
     target = hints.target || connection.target,
     waypoints = hints.waypoints || connection.waypoints,
     connectionStart = hints.connectionStart,
     connectionEnd = hints.connectionEnd;
55954
 var manhattanOptions,
     updatedWaypoints;
55957
 if (!connectionStart) {
   connectionStart = getConnectionDocking(waypoints && waypoints[ 0 ], source);
 }
55961
 if (!connectionEnd) {
   connectionEnd = getConnectionDocking(waypoints && waypoints[ waypoints.length - 1 ], target);
 }
55965
 // TODO(nikku): support vertical modeling
 // and invert preferredLayouts accordingly
55968
 if (is$1(connection, 'bpmn:Association') ||
     is$1(connection, 'bpmn:DataAssociation')) {
55971
   if (waypoints && !isCompensationAssociation(source, target)) {
     return [].concat([ connectionStart ], waypoints.slice(1, -1), [ connectionEnd ]);
   }
 }
55976
 if (is$1(connection, 'bpmn:MessageFlow')) {
   manhattanOptions = getMessageFlowManhattanOptions(source, target);
 } else if (is$1(connection, 'bpmn:SequenceFlow') || isCompensationAssociation(source, target)) {
55980
   // layout all connection between flow elements h:h, except for
   // (1) outgoing of boundary events -> layout based on attach orientation and target orientation
   // (2) incoming/outgoing of gateways -> v:h for outgoing, h:v for incoming
   // (3) loops
   if (source === target) {
     manhattanOptions = {
       preferredLayouts: getLoopPreferredLayout(source, connection)
     };
   } else if (is$1(source, 'bpmn:BoundaryEvent')) {
     manhattanOptions = {
       preferredLayouts: getBoundaryEventPreferredLayouts(source, target, connectionEnd)
     };
   } else if (isExpandedSubProcess(source) || isExpandedSubProcess(target)) {
     manhattanOptions = getSubProcessManhattanOptions(source);
   } else if (is$1(source, 'bpmn:Gateway')) {
     manhattanOptions = {
       preferredLayouts: [ 'v:h' ]
     };
   } else if (is$1(target, 'bpmn:Gateway')) {
     manhattanOptions = {
       preferredLayouts: [ 'h:v' ]
     };
   } else {
     manhattanOptions = {
       preferredLayouts: [ 'h:h' ]
     };
   }
 }
56009
 if (manhattanOptions) {
   manhattanOptions = assign(manhattanOptions, hints);
56012
   updatedWaypoints = withoutRedundantPoints(repairConnection(
     source,
     target,
     connectionStart,
     connectionEnd,
     waypoints,
     manhattanOptions
   ));
 }
56022
 return updatedWaypoints || [ connectionStart, connectionEnd ];
};
56025
56026
// helpers //////////
56028
function getAttachOrientation(attachedElement) {
 var hostElement = attachedElement.host;
56031
 return getOrientation(getMid(attachedElement), hostElement, ATTACH_ORIENTATION_PADDING);
}
56034
function getMessageFlowManhattanOptions(source, target) {
 return {
   preferredLayouts: [ 'straight', 'v:v' ],
   preserveDocking: getMessageFlowPreserveDocking(source, target)
 };
}
56041
function getMessageFlowPreserveDocking(source, target) {
56043
 // (1) docking element connected to participant has precedence
 if (is$1(target, 'bpmn:Participant')) {
   return 'source';
 }
56048
 if (is$1(source, 'bpmn:Participant')) {
   return 'target';
 }
56052
 // (2) docking element connected to expanded sub-process has precedence
 if (isExpandedSubProcess(target)) {
   return 'source';
 }
56057
 if (isExpandedSubProcess(source)) {
   return 'target';
 }
56061
 // (3) docking event has precedence
 if (is$1(target, 'bpmn:Event')) {
   return 'target';
 }
56066
 if (is$1(source, 'bpmn:Event')) {
   return 'source';
 }
56070
 return null;
}
56073
function getSubProcessManhattanOptions(source) {
 return {
   preferredLayouts: [ 'straight', 'h:h' ],
   preserveDocking: getSubProcessPreserveDocking(source)
 };
}
56080
function getSubProcessPreserveDocking(source) {
 return isExpandedSubProcess(source) ? 'target' : 'source';
}
56084
function getConnectionDocking(point, shape) {
 return point ? (point.original || point) : getMid(shape);
}
56088
function isCompensationAssociation(source, target) {
 return is$1(target, 'bpmn:Activity') &&
   is$1(source, 'bpmn:BoundaryEvent') &&
   target.businessObject.isForCompensation;
}
56094
function isExpandedSubProcess(element) {
 return is$1(element, 'bpmn:SubProcess') && isExpanded(element);
}
56098
function isSame(a, b) {
 return a === b;
}
56102
function isAnyOrientation(orientation, orientations) {
 return orientations.indexOf(orientation) !== -1;
}
56106
function getHorizontalOrientation(orientation) {
 var matches = /right|left/.exec(orientation);
56109
 return matches && matches[0];
}
56112
function getVerticalOrientation(orientation) {
 var matches = /top|bottom/.exec(orientation);
56115
 return matches && matches[0];
}
56118
function isOppositeOrientation(a, b) {
 return oppositeOrientationMapping[a] === b;
}
56122
function isOppositeHorizontalOrientation(a, b) {
 var horizontalOrientation = getHorizontalOrientation(a);
56125
 var oppositeHorizontalOrientation = oppositeOrientationMapping[horizontalOrientation];
56127
 return b.indexOf(oppositeHorizontalOrientation) !== -1;
}
56130
function isOppositeVerticalOrientation(a, b) {
 var verticalOrientation = getVerticalOrientation(a);
56133
 var oppositeVerticalOrientation = oppositeOrientationMapping[verticalOrientation];
56135
 return b.indexOf(oppositeVerticalOrientation) !== -1;
}
56138
function isHorizontalOrientation(orientation) {
 return orientation === 'right' || orientation === 'left';
}
56142
function getLoopPreferredLayout(source, connection) {
 var waypoints = connection.waypoints;
56145
 var orientation = waypoints && waypoints.length && getOrientation(waypoints[0], source);
56147
 if (orientation === 'top') {
   return [ 't:r' ];
 } else if (orientation === 'right') {
   return [ 'r:b' ];
 } else if (orientation === 'left') {
   return [ 'l:t' ];
 }
56155
 return [ 'b:l' ];
}
56158
function getBoundaryEventPreferredLayouts(source, target, end) {
 var sourceMid = getMid(source),
     targetMid = getMid(target),
     attachOrientation = getAttachOrientation(source),
     sourceLayout,
     targetLayout;
56165
 var isLoop = isSame(source.host, target);
56167
 var attachedToSide = isAnyOrientation(attachOrientation, [ 'top', 'right', 'bottom', 'left' ]);
56169
 var targetOrientation = getOrientation(targetMid, sourceMid, {
   x: source.width / 2 + target.width / 2,
   y: source.height / 2 + target.height / 2
 });
56174
 if (isLoop) {
   return getBoundaryEventLoopLayout(attachOrientation, attachedToSide, source, target, end);
 }
56178
 // source layout
 sourceLayout = getBoundaryEventSourceLayout(attachOrientation, targetOrientation, attachedToSide);
56181
 // target layout
 targetLayout = getBoundaryEventTargetLayout(attachOrientation, targetOrientation, attachedToSide);
56184
 return [ sourceLayout + ':' + targetLayout ];
}
56187
function getBoundaryEventLoopLayout(attachOrientation, attachedToSide, source, target, end) {
 var orientation = attachedToSide ? attachOrientation : getVerticalOrientation(attachOrientation),
     sourceLayout = orientationDirectionMapping[ orientation ],
     targetLayout;
56192
 if (attachedToSide) {
   if (isHorizontalOrientation(attachOrientation)) {
     targetLayout = shouldConnectToSameSide('y', source, target, end) ? 'h' : 'b';
   } else {
     targetLayout = shouldConnectToSameSide('x', source, target, end) ? 'v' : 'l';
   }
 } else {
   targetLayout = 'v';
 }
56202
 return [ sourceLayout + ':' + targetLayout ];
}
56205
function shouldConnectToSameSide(axis, source, target, end) {
 var threshold = BOUNDARY_TO_HOST_THRESHOLD$1;
56208
 return !(
   areCloseOnAxis(axis, end, target, threshold) ||
   areCloseOnAxis(axis, end, {
     x: target.x + target.width,
     y: target.y + target.height
   }, threshold) ||
   areCloseOnAxis(axis, end, getMid(source), threshold)
 );
}
56218
function areCloseOnAxis(axis, a, b, threshold) {
 return Math.abs(a[ axis ] - b[ axis ]) < threshold;
}
56222
function getBoundaryEventSourceLayout(attachOrientation, targetOrientation, attachedToSide) {
56224
 // attached to either top, right, bottom or left side
 if (attachedToSide) {
   return orientationDirectionMapping[ attachOrientation ];
 }
56229
 // attached to either top-right, top-left, bottom-right or bottom-left corner
56231
 // same vertical or opposite horizontal orientation
 if (isSame(
   getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation)
 ) || isOppositeOrientation(
   getHorizontalOrientation(attachOrientation), getHorizontalOrientation(targetOrientation)
 )) {
   return orientationDirectionMapping[ getVerticalOrientation(attachOrientation) ];
 }
56240
 // fallback
 return orientationDirectionMapping[ getHorizontalOrientation(attachOrientation) ];
}
56244
function getBoundaryEventTargetLayout(attachOrientation, targetOrientation, attachedToSide) {
56246
 // attached to either top, right, bottom or left side
 if (attachedToSide) {
   if (isHorizontalOrientation(attachOrientation)) {
56250
     // orientation is right or left
56252
     // opposite horizontal orientation or same orientation
     if (
       isOppositeHorizontalOrientation(attachOrientation, targetOrientation) ||
       isSame(attachOrientation, targetOrientation)
     ) {
       return 'h';
     }
56260
     // fallback
     return 'v';
   } else {
56264
     // orientation is top or bottom
56266
     // opposite vertical orientation or same orientation
     if (
       isOppositeVerticalOrientation(attachOrientation, targetOrientation) ||
       isSame(attachOrientation, targetOrientation)
     ) {
       return 'v';
     }
56274
     // fallback
     return 'h';
   }
 }
56279
 // attached to either top-right, top-left, bottom-right or bottom-left corner
56281
 // orientation is right, left
 // or same vertical orientation but also right or left
 if (isHorizontalOrientation(targetOrientation) ||
   (isSame(getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation)) &&
     getHorizontalOrientation(targetOrientation))) {
   return 'h';
 } else {
   return 'v';
 }
}
56292
function dockingToPoint(docking) {
56294
 // use the dockings actual point and
 // retain the original docking
 return assign({ original: docking.point.original || docking.point }, docking.actual);
}
56299
56300
/**
* A {@link ConnectionDocking} that crops connection waypoints based on
* the path(s) of the connection source and target.
*
* @param {djs.core.ElementRegistry} elementRegistry
*/
function CroppingConnectionDocking(elementRegistry, graphicsFactory) {
 this._elementRegistry = elementRegistry;
 this._graphicsFactory = graphicsFactory;
}
56311
CroppingConnectionDocking.$inject = [ 'elementRegistry', 'graphicsFactory' ];
56313
56314
/**
* @inheritDoc ConnectionDocking#getCroppedWaypoints
*/
CroppingConnectionDocking.prototype.getCroppedWaypoints = function(connection, source, target) {
56319
 source = source || connection.source;
 target = target || connection.target;
56322
 var sourceDocking = this.getDockingPoint(connection, source, true),
     targetDocking = this.getDockingPoint(connection, target);
56325
 var croppedWaypoints = connection.waypoints.slice(sourceDocking.idx + 1, targetDocking.idx);
56327
 croppedWaypoints.unshift(dockingToPoint(sourceDocking));
 croppedWaypoints.push(dockingToPoint(targetDocking));
56330
 return croppedWaypoints;
};
56333
/**
* Return the connection docking point on the specified shape
*
* @inheritDoc ConnectionDocking#getDockingPoint
*/
CroppingConnectionDocking.prototype.getDockingPoint = function(connection, shape, dockStart) {
56340
 var waypoints = connection.waypoints,
     dockingIdx,
     dockingPoint,
     croppedPoint;
56345
 dockingIdx = dockStart ? 0 : waypoints.length - 1;
 dockingPoint = waypoints[dockingIdx];
56348
 croppedPoint = this._getIntersection(shape, connection, dockStart);
56350
 return {
   point: dockingPoint,
   actual: croppedPoint || dockingPoint,
   idx: dockingIdx
 };
};
56357
56358
// helpers //////////////////////
56360
CroppingConnectionDocking.prototype._getIntersection = function(shape, connection, takeFirst) {
56362
 var shapePath = this._getShapePath(shape),
     connectionPath = this._getConnectionPath(connection);
56365
 return getElementLineIntersection(shapePath, connectionPath, takeFirst);
};
56368
CroppingConnectionDocking.prototype._getConnectionPath = function(connection) {
 return this._graphicsFactory.getConnectionPath(connection);
};
56372
CroppingConnectionDocking.prototype._getShapePath = function(shape) {
 return this._graphicsFactory.getShapePath(shape);
};
56376
CroppingConnectionDocking.prototype._getGfx = function(element) {
 return this._elementRegistry.getGraphics(element);
};
56380
var ModelingModule = {
 __init__: [
   'modeling',
   'bpmnUpdater'
 ],
 __depends__: [
   BehaviorModule,
   RulesModule,
   DiOrderingModule,
   OrderingModule,
   ReplaceModule,
   CommandModule,
   TooltipsModule,
   LabelSupportModule,
   AttachSupportModule,
   SelectionModule,
   ChangeSupportModule,
   SpaceToolModule
 ],
 bpmnFactory: [ 'type', BpmnFactory ],
 bpmnUpdater: [ 'type', BpmnUpdater ],
 elementFactory: [ 'type', ElementFactory ],
 modeling: [ 'type', Modeling ],
 layouter: [ 'type', BpmnLayouter ],
 connectionDocking: [ 'type', CroppingConnectionDocking ]
};
56407
var LOW_PRIORITY$2 = 500,
   MEDIUM_PRIORITY = 1250,
   HIGH_PRIORITY$2 = 1500;
56411
var round = Math.round;
56413
function mid(element) {
 return {
   x: element.x + round(element.width / 2),
   y: element.y + round(element.height / 2)
 };
}
56420
/**
* A plugin that makes shapes draggable / droppable.
*
* @param {EventBus} eventBus
* @param {Dragging} dragging
* @param {Modeling} modeling
* @param {Selection} selection
* @param {Rules} rules
*/
function MoveEvents(
   eventBus, dragging, modeling,
   selection, rules) {
56433
 // rules
56435
 function canMove(shapes, delta, position, target) {
56437
   return rules.allowed('elements.move', {
     shapes: shapes,
     delta: delta,
     position: position,
     target: target
   });
 }
56445
56446
 // move events
56448
 // assign a high priority to this handler to setup the environment
 // others may hook up later, e.g. at default priority and modify
 // the move environment.
 //
 // This sets up the context with
 //
 // * shape: the primary shape being moved
 // * shapes: a list of shapes to be moved
 // * validatedShapes: a list of shapes that are being checked
 //                    against the rules before and during move
 //
 eventBus.on('shape.move.start', HIGH_PRIORITY$2, function(event) {
56461
   var context = event.context,
       shape = event.shape,
       shapes = selection.get().slice();
56465
   // move only single shape if the dragged element
   // is not part of the current selection
   if (shapes.indexOf(shape) === -1) {
     shapes = [ shape ];
   }
56471
   // ensure we remove nested elements in the collection
   // and add attachers for a proper dragger
   shapes = removeNested(shapes);
56475
   // attach shapes to drag context
   assign(context, {
     shapes: shapes,
     validatedShapes: shapes,
     shape: shape
   });
 });
56483
56484
 // assign a high priority to this handler to setup the environment
 // others may hook up later, e.g. at default priority and modify
 // the move environment
 //
 eventBus.on('shape.move.start', MEDIUM_PRIORITY, function(event) {
56490
   var context = event.context,
       validatedShapes = context.validatedShapes,
       canExecute;
56494
   canExecute = context.canExecute = canMove(validatedShapes);
56496
   // check if we can move the elements
   if (!canExecute) {
     return false;
   }
 });
56502
 // assign a low priority to this handler
 // to let others modify the move event before we update
 // the context
 //
 eventBus.on('shape.move.move', LOW_PRIORITY$2, function(event) {
56508
   var context = event.context,
       validatedShapes = context.validatedShapes,
       hover = event.hover,
       delta = { x: event.dx, y: event.dy },
       position = { x: event.x, y: event.y },
       canExecute;
56515
   // check if we can move the elements
   canExecute = canMove(validatedShapes, delta, position, hover);
56518
   context.delta = delta;
   context.canExecute = canExecute;
56521
   // simply ignore move over
   if (canExecute === null) {
     context.target = null;
56525
     return;
   }
56528
   context.target = hover;
 });
56531
 eventBus.on('shape.move.end', function(event) {
56533
   var context = event.context;
56535
   var delta = context.delta,
       canExecute = context.canExecute,
       isAttach = canExecute === 'attach',
       shapes = context.shapes;
56540
   if (canExecute === false) {
     return false;
   }
56544
   // ensure we have actual pixel values deltas
   // (important when zoom level was > 1 during move)
   delta.x = round(delta.x);
   delta.y = round(delta.y);
56549
   if (delta.x === 0 && delta.y === 0) {
56551
     // didn't move
     return;
   }
56555
   modeling.moveElements(shapes, delta, context.target, {
     primaryShape: context.shape,
     attach: isAttach
   });
 });
56561
56562
 // move activation
56564
 eventBus.on('element.mousedown', function(event) {
56566
   if (!isPrimaryButton(event)) {
     return;
   }
56570
   var originalEvent = getOriginal$1(event);
56572
   if (!originalEvent) {
     throw new Error('must supply DOM mousedown event');
   }
56576
   return start(originalEvent, event.element);
 });
56579
 /**
  * Start move.
  *
  * @param {MouseEvent} event
  * @param {djs.model.Shape} shape
  * @param {boolean} [activate]
  * @param {Object} [context]
  */
 function start(event, element, activate, context) {
   if (isObject(activate)) {
     context = activate;
     activate = false;
   }
56593
   // do not move connections or the root element
   if (element.waypoints || !element.parent) {
     return;
   }
56598
   // ignore non-draggable hits
   if (classes$1(event.target).has('djs-hit-no-move')) {
     return;
   }
56603
   var referencePoint = mid(element);
56605
   dragging.init(event, referencePoint, 'shape.move', {
     cursor: 'grabbing',
     autoActivate: activate,
     data: {
       shape: element,
       context: context || {}
     }
   });
56614
   // we've handled the event
   return true;
 }
56618
 // API
56620
 this.start = start;
}
56623
MoveEvents.$inject = [
 'eventBus',
 'dragging',
 'modeling',
 'selection',
 'rules'
];
56631
56632
/**
* Return a filtered list of elements that do not contain
* those nested into others.
*
* @param  {Array<djs.model.Base>} elements
*
* @return {Array<djs.model.Base>} filtered
*/
function removeNested(elements) {
56642
 var ids = groupBy(elements, 'id');
56644
 return filter(elements, function(element) {
   while ((element = element.parent)) {
56647
     // parent in selection
     if (ids[element.id]) {
       return false;
     }
   }
56653
   return true;
 });
}
56657
var LOW_PRIORITY$1 = 499;
56659
var MARKER_DRAGGING = 'djs-dragging',
   MARKER_OK$1 = 'drop-ok',
   MARKER_NOT_OK$1 = 'drop-not-ok',
   MARKER_NEW_PARENT = 'new-parent',
   MARKER_ATTACH = 'attach-ok';
56665
56666
/**
* Provides previews for moving shapes when moving.
*
* @param {EventBus} eventBus
* @param {ElementRegistry} elementRegistry
* @param {Canvas} canvas
* @param {Styles} styles
*/
function MovePreview(
   eventBus, canvas, styles, previewSupport) {
56677
 function getVisualDragShapes(shapes) {
   var elements = getAllDraggedElements(shapes);
56680
   var filteredElements = removeEdges(elements);
56682
   return filteredElements;
 }
56685
 function getAllDraggedElements(shapes) {
   var allShapes = selfAndAllChildren(shapes, true);
56688
   var allConnections = map(allShapes, function(shape) {
     return (shape.incoming || []).concat(shape.outgoing || []);
   });
56692
   return flatten(allShapes.concat(allConnections));
 }
56695
 /**
  * Sets drop marker on an element.
  */
 function setMarker(element, marker) {
56700
   [ MARKER_ATTACH, MARKER_OK$1, MARKER_NOT_OK$1, MARKER_NEW_PARENT ].forEach(function(m) {
56702
     if (m === marker) {
       canvas.addMarker(element, m);
     } else {
       canvas.removeMarker(element, m);
     }
   });
 }
56710
 /**
  * Make an element draggable.
  *
  * @param {Object} context
  * @param {djs.model.Base} element
  * @param {boolean} addMarker
  */
 function makeDraggable(context, element, addMarker) {
56719
   previewSupport.addDragger(element, context.dragGroup);
56721
   if (addMarker) {
     canvas.addMarker(element, MARKER_DRAGGING);
   }
56725
   if (context.allDraggedElements) {
     context.allDraggedElements.push(element);
   } else {
     context.allDraggedElements = [ element ];
   }
 }
56732
 // assign a low priority to this handler
 // to let others modify the move context before
 // we draw things
 eventBus.on('shape.move.start', LOW_PRIORITY$1, function(event) {
   var context = event.context,
       dragShapes = context.shapes,
       allDraggedElements = context.allDraggedElements;
56740
   var visuallyDraggedShapes = getVisualDragShapes(dragShapes);
56742
   if (!context.dragGroup) {
     var dragGroup = create$1('g');
56745
     attr$1(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));
56747
     var activeLayer = canvas.getActiveLayer();
56749
     append(activeLayer, dragGroup);
56751
     context.dragGroup = dragGroup;
   }
56754
   // add previews
   visuallyDraggedShapes.forEach(function(shape) {
     previewSupport.addDragger(shape, context.dragGroup);
   });
56759
   // cache all dragged elements / gfx
   // so that we can quickly undo their state changes later
   if (!allDraggedElements) {
     allDraggedElements = getAllDraggedElements(dragShapes);
   } else {
     allDraggedElements = flatten([
       allDraggedElements,
       getAllDraggedElements(dragShapes)
     ]);
   }
56770
   // add dragging marker
   forEach$2(allDraggedElements, function(e) {
     canvas.addMarker(e, MARKER_DRAGGING);
   });
56775
   context.allDraggedElements = allDraggedElements;
56777
   // determine, if any of the dragged elements have different parents
   context.differentParents = haveDifferentParents(dragShapes);
 });
56781
 // update previews
 eventBus.on('shape.move.move', LOW_PRIORITY$1, function(event) {
56784
   var context = event.context,
       dragGroup = context.dragGroup,
       target = context.target,
       parent = context.shape.parent,
       canExecute = context.canExecute;
56790
   if (target) {
     if (canExecute === 'attach') {
       setMarker(target, MARKER_ATTACH);
     } else if (context.canExecute && target && target.id !== parent.id) {
       setMarker(target, MARKER_NEW_PARENT);
     } else {
       setMarker(target, context.canExecute ? MARKER_OK$1 : MARKER_NOT_OK$1);
     }
   }
56800
   translate$2(dragGroup, event.dx, event.dy);
 });
56803
 eventBus.on([ 'shape.move.out', 'shape.move.cleanup' ], function(event) {
   var context = event.context,
       target = context.target;
56807
   if (target) {
     setMarker(target, null);
   }
 });
56812
 // remove previews
 eventBus.on('shape.move.cleanup', function(event) {
56815
   var context = event.context,
       allDraggedElements = context.allDraggedElements,
       dragGroup = context.dragGroup;
56819
56820
   // remove dragging marker
   forEach$2(allDraggedElements, function(e) {
     canvas.removeMarker(e, MARKER_DRAGGING);
   });
56825
   if (dragGroup) {
     remove$2(dragGroup);
   }
 });
56830
56831
 // API //////////////////////
56833
 /**
  * Make an element draggable.
  *
  * @param {Object} context
  * @param {djs.model.Base} element
  * @param {boolean} addMarker
  */
 this.makeDraggable = makeDraggable;
}
56843
MovePreview.$inject = [
 'eventBus',
 'canvas',
 'styles',
 'previewSupport'
];
56850
56851
// helpers //////////////////////
56853
/**
* returns elements minus all connections
* where source or target is not elements
*/
function removeEdges(elements) {
56859
 var filteredElements = filter(elements, function(element) {
56861
   if (!isConnection$2(element)) {
     return true;
   } else {
56865
     return (
       find(elements, matchPattern({ id: element.source.id })) &&
       find(elements, matchPattern({ id: element.target.id }))
     );
   }
 });
56872
 return filteredElements;
}
56875
function haveDifferentParents(elements) {
 return size(groupBy(elements, function(e) { return e.parent && e.parent.id; })) !== 1;
}
56879
/**
* Checks if an element is a connection.
*/
function isConnection$2(element) {
 return element.waypoints;
}
56886
var MoveModule = {
 __depends__: [
   InteractionEventsModule$1,
   SelectionModule,
   OutlineModule,
   RulesModule$1,
   DraggingModule,
   PreviewSupportModule
 ],
 __init__: [
   'move',
   'movePreview'
 ],
 move: [ 'type', MoveEvents ],
 movePreview: [ 'type', MovePreview ]
};
56903
var TOGGLE_SELECTOR = '.djs-palette-toggle',
   ENTRY_SELECTOR = '.entry',
   ELEMENT_SELECTOR = TOGGLE_SELECTOR + ', ' + ENTRY_SELECTOR;
56907
var PALETTE_PREFIX = 'djs-palette-',
   PALETTE_SHOWN_CLS = 'shown',
   PALETTE_OPEN_CLS = 'open',
   PALETTE_TWO_COLUMN_CLS = 'two-column';
56912
var DEFAULT_PRIORITY = 1000;
56914
56915
/**
* A palette containing modeling elements.
*/
function Palette(eventBus, canvas) {
56920
 this._eventBus = eventBus;
 this._canvas = canvas;
56923
 var self = this;
56925
 eventBus.on('tool-manager.update', function(event) {
   var tool = event.tool;
56928
   self.updateToolHighlight(tool);
 });
56931
 eventBus.on('i18n.changed', function() {
   self._update();
 });
56935
 eventBus.on('diagram.init', function() {
56937
   self._diagramInitialized = true;
56939
   self._rebuild();
 });
}
56943
Palette.$inject = [ 'eventBus', 'canvas' ];
56945
56946
/**
* Register a provider with the palette
*
* @param  {number} [priority=1000]
* @param  {PaletteProvider} provider
*
* @example
* const paletteProvider = {
*   getPaletteEntries: function() {
*     return function(entries) {
*       return {
*         ...entries,
*         'entry-1': {
*           label: 'My Entry',
*           action: function() { alert("I have been clicked!"); }
*         }
*       };
*     }
*   }
* };
*
* palette.registerProvider(800, paletteProvider);
*/
Palette.prototype.registerProvider = function(priority, provider) {
 if (!provider) {
   provider = priority;
   priority = DEFAULT_PRIORITY;
 }
56975
 this._eventBus.on('palette.getProviders', priority, function(event) {
   event.providers.push(provider);
 });
56979
 this._rebuild();
};
56982
56983
/**
* Returns the palette entries
*
* @return {Object<string, PaletteEntryDescriptor>} map of entries
*/
Palette.prototype.getEntries = function() {
 var providers = this._getProviders();
56991
 return providers.reduce(addPaletteEntries, {});
};
56994
Palette.prototype._rebuild = function() {
56996
 if (!this._diagramInitialized) {
   return;
 }
57000
 var providers = this._getProviders();
57002
 if (!providers.length) {
   return;
 }
57006
 if (!this._container) {
   this._init();
 }
57010
 this._update();
};
57013
/**
* Initialize
*/
Palette.prototype._init = function() {
57018
 var self = this;
57020
 var eventBus = this._eventBus;
57022
 var parentContainer = this._getParentContainer();
57024
 var container = this._container = domify(Palette.HTML_MARKUP);
57026
 parentContainer.appendChild(container);
 classes(parentContainer).add(PALETTE_PREFIX + PALETTE_SHOWN_CLS);
57029
 delegate.bind(container, ELEMENT_SELECTOR, 'click', function(event) {
57031
   var target = event.delegateTarget;
57033
   if (matchesSelector(target, TOGGLE_SELECTOR)) {
     return self.toggle();
   }
57037
   self.trigger('click', event);
 });
57040
 // prevent drag propagation
 componentEvent.bind(container, 'mousedown', function(event) {
   event.stopPropagation();
 });
57045
 // prevent drag propagation
 delegate.bind(container, ENTRY_SELECTOR, 'dragstart', function(event) {
   self.trigger('dragstart', event);
 });
57050
 eventBus.on('canvas.resized', this._layoutChanged, this);
57052
 eventBus.fire('palette.create', {
   container: container
 });
};
57057
Palette.prototype._getProviders = function(id) {
57059
 var event = this._eventBus.createEvent({
   type: 'palette.getProviders',
   providers: []
 });
57064
 this._eventBus.fire(event);
57066
 return event.providers;
};
57069
/**
* Update palette state.
*
* @param  {Object} [state] { open, twoColumn }
*/
Palette.prototype._toggleState = function(state) {
57076
 state = state || {};
57078
 var parent = this._getParentContainer(),
     container = this._container;
57081
 var eventBus = this._eventBus;
57083
 var twoColumn;
57085
 var cls = classes(container),
     parentCls = classes(parent);
57088
 if ('twoColumn' in state) {
   twoColumn = state.twoColumn;
 } else {
   twoColumn = this._needsCollapse(parent.clientHeight, this._entries || {});
 }
57094
 // always update two column
 cls.toggle(PALETTE_TWO_COLUMN_CLS, twoColumn);
 parentCls.toggle(PALETTE_PREFIX + PALETTE_TWO_COLUMN_CLS, twoColumn);
57098
 if ('open' in state) {
   cls.toggle(PALETTE_OPEN_CLS, state.open);
   parentCls.toggle(PALETTE_PREFIX + PALETTE_OPEN_CLS, state.open);
 }
57103
 eventBus.fire('palette.changed', {
   twoColumn: twoColumn,
   open: this.isOpen()
 });
};
57109
Palette.prototype._update = function() {
57111
 var entriesContainer = query('.djs-palette-entries', this._container),
     entries = this._entries = this.getEntries();
57114
 clear(entriesContainer);
57116
 forEach$2(entries, function(entry, id) {
57118
   var grouping = entry.group || 'default';
57120
   var container = query('[data-group=' + grouping + ']', entriesContainer);
   if (!container) {
     container = domify('<div class="group" data-group="' + grouping + '"></div>');
     entriesContainer.appendChild(container);
   }
57126
   var html = entry.html || (
     entry.separator ?
       '<hr class="separator" />' :
       '<div class="entry" draggable="true"></div>');
57131
57132
   var control = domify(html);
   container.appendChild(control);
57135
   if (!entry.separator) {
     attr(control, 'data-action', id);
57138
     if (entry.title) {
       attr(control, 'title', entry.title);
     }
57142
     if (entry.className) {
       addClasses(control, entry.className);
     }
57146
     if (entry.imageUrl) {
       control.appendChild(domify('<img src="' + entry.imageUrl + '">'));
     }
   }
 });
57152
 // open after update
 this.open();
};
57156
57157
/**
* Trigger an action available on the palette
*
* @param  {string} action
* @param  {Event} event
*/
Palette.prototype.trigger = function(action, event, autoActivate) {
 var entries = this._entries,
     entry,
     handler,
     originalEvent,
     button = event.delegateTarget || event.target;
57170
 if (!button) {
   return event.preventDefault();
 }
57174
 entry = entries[attr(button, 'data-action')];
57176
 // when user clicks on the palette and not on an action
 if (!entry) {
   return;
 }
57181
 handler = entry.action;
57183
 originalEvent = event.originalEvent || event;
57185
 // simple action (via callback function)
 if (isFunction(handler)) {
   if (action === 'click') {
     handler(originalEvent, autoActivate);
   }
 } else {
   if (handler[action]) {
     handler[action](originalEvent, autoActivate);
   }
 }
57196
 // silence other actions
 event.preventDefault();
};
57200
Palette.prototype._layoutChanged = function() {
 this._toggleState({});
};
57204
/**
* Do we need to collapse to two columns?
*
* @param {number} availableHeight
* @param {Object} entries
*
* @return {boolean}
*/
Palette.prototype._needsCollapse = function(availableHeight, entries) {
57214
 // top margin + bottom toggle + bottom margin
 // implementors must override this method if they
 // change the palette styles
 var margin = 20 + 10 + 20;
57219
 var entriesHeight = Object.keys(entries).length * 46;
57221
 return availableHeight < entriesHeight + margin;
};
57224
/**
* Close the palette
*/
Palette.prototype.close = function() {
57229
 this._toggleState({
   open: false,
   twoColumn: false
 });
};
57235
57236
/**
* Open the palette
*/
Palette.prototype.open = function() {
 this._toggleState({ open: true });
};
57243
57244
Palette.prototype.toggle = function(open) {
 if (this.isOpen()) {
   this.close();
 } else {
   this.open();
 }
};
57252
Palette.prototype.isActiveTool = function(tool) {
 return tool && this._activeTool === tool;
};
57256
Palette.prototype.updateToolHighlight = function(name) {
 var entriesContainer,
     toolsContainer;
57260
 if (!this._toolsContainer) {
   entriesContainer = query('.djs-palette-entries', this._container);
57263
   this._toolsContainer = query('[data-group=tools]', entriesContainer);
 }
57266
 toolsContainer = this._toolsContainer;
57268
 forEach$2(toolsContainer.children, function(tool) {
   var actionName = tool.getAttribute('data-action');
57271
   if (!actionName) {
     return;
   }
57275
   var toolClasses = classes(tool);
57277
   actionName = actionName.replace('-tool', '');
57279
   if (toolClasses.contains('entry') && actionName === name) {
     toolClasses.add('highlighted-entry');
   } else {
     toolClasses.remove('highlighted-entry');
   }
 });
};
57287
57288
/**
* Return true if the palette is opened.
*
* @example
*
* palette.open();
*
* if (palette.isOpen()) {
*   // yes, we are open
* }
*
* @return {boolean} true if palette is opened
*/
Palette.prototype.isOpen = function() {
 return classes(this._container).has(PALETTE_OPEN_CLS);
};
57305
/**
* Get container the palette lives in.
*
* @return {Element}
*/
Palette.prototype._getParentContainer = function() {
 return this._canvas.getContainer();
};
57314
57315
/* markup definition */
57317
Palette.HTML_MARKUP =
 '<div class="djs-palette">' +
   '<div class="djs-palette-entries"></div>' +
   '<div class="djs-palette-toggle"></div>' +
 '</div>';
57323
57324
// helpers //////////////////////
57326
function addClasses(element, classNames) {
57328
 var classes$1 = classes(element);
57330
 var actualClassNames = isArray$4(classNames) ? classNames : classNames.split(/\s+/g);
 actualClassNames.forEach(function(cls) {
   classes$1.add(cls);
 });
}
57336
function addPaletteEntries(entries, provider) {
57338
 var entriesOrUpdater = provider.getPaletteEntries();
57340
 if (isFunction(entriesOrUpdater)) {
   return entriesOrUpdater(entries);
 }
57344
 forEach$2(entriesOrUpdater, function(entry, id) {
   entries[id] = entry;
 });
57348
 return entries;
}
57351
var PaletteModule$1 = {
 __init__: [ 'palette' ],
 palette: [ 'type', Palette ]
};
57356
var LASSO_TOOL_CURSOR = 'crosshair';
57358
57359
function LassoTool(
   eventBus, canvas, dragging,
   elementRegistry, selection, toolManager,
   mouse) {
57364
 this._selection = selection;
 this._dragging = dragging;
 this._mouse = mouse;
57368
 var self = this;
57370
 // lasso visuals implementation
57372
 /**
 * A helper that realizes the selection box visual
 */
 var visuals = {
57377
   create: function(context) {
     var container = canvas.getActiveLayer(),
         frame;
57381
     frame = context.frame = create$1('rect');
     attr$1(frame, {
       class: 'djs-lasso-overlay',
       width:  1,
       height: 1,
       x: 0,
       y: 0
     });
57390
     append(container, frame);
   },
57393
   update: function(context) {
     var frame = context.frame,
         bbox = context.bbox;
57397
     attr$1(frame, {
       x: bbox.x,
       y: bbox.y,
       width: bbox.width,
       height: bbox.height
     });
   },
57405
   remove: function(context) {
57407
     if (context.frame) {
       remove$2(context.frame);
     }
   }
 };
57413
 toolManager.registerTool('lasso', {
   tool: 'lasso.selection',
   dragging: 'lasso'
 });
57418
 eventBus.on('lasso.selection.end', function(event) {
   var target = event.originalEvent.target;
57421
   // only reactive on diagram click
   // on some occasions, event.hover is not set and we have to check if the target is an svg
   if (!event.hover && !(target instanceof SVGElement)) {
     return;
   }
57427
   eventBus.once('lasso.selection.ended', function() {
     self.activateLasso(event.originalEvent, true);
   });
 });
57432
 // lasso interaction implementation
57434
 eventBus.on('lasso.end', function(event) {
57436
   var bbox = toBBox(event);
57438
   var elements = elementRegistry.filter(function(element) {
     return element;
   });
57442
   self.select(elements, bbox);
 });
57445
 eventBus.on('lasso.start', function(event) {
57447
   var context = event.context;
57449
   context.bbox = toBBox(event);
   visuals.create(context);
 });
57453
 eventBus.on('lasso.move', function(event) {
57455
   var context = event.context;
57457
   context.bbox = toBBox(event);
   visuals.update(context);
 });
57461
 eventBus.on('lasso.cleanup', function(event) {
57463
   var context = event.context;
57465
   visuals.remove(context);
 });
57468
57469
 // event integration
57471
 eventBus.on('element.mousedown', 1500, function(event) {
57473
   if (!hasSecondaryModifier(event)) {
     return;
   }
57477
   self.activateLasso(event.originalEvent);
57479
   // we've handled the event
   return true;
 });
}
57484
LassoTool.$inject = [
 'eventBus',
 'canvas',
 'dragging',
 'elementRegistry',
 'selection',
 'toolManager',
 'mouse'
];
57494
57495
LassoTool.prototype.activateLasso = function(event, autoActivate) {
57497
 this._dragging.init(event, 'lasso', {
   autoActivate: autoActivate,
   cursor: LASSO_TOOL_CURSOR,
   data: {
     context: {}
   }
 });
};
57506
LassoTool.prototype.activateSelection = function(event, autoActivate) {
57508
 this._dragging.init(event, 'lasso.selection', {
   trapClick: false,
   autoActivate: autoActivate,
   cursor: LASSO_TOOL_CURSOR,
   data: {
     context: {}
   }
 });
};
57518
LassoTool.prototype.select = function(elements, bbox) {
 var selectedElements = getEnclosedElements(elements, bbox);
57521
 this._selection.select(values(selectedElements));
};
57524
LassoTool.prototype.toggle = function() {
 if (this.isActive()) {
   return this._dragging.cancel();
 }
57529
 var mouseEvent = this._mouse.getLastMoveEvent();
57531
 this.activateSelection(mouseEvent, !!mouseEvent);
};
57534
LassoTool.prototype.isActive = function() {
 var context = this._dragging.context();
57537
 return context && /^lasso/.test(context.prefix);
};
57540
57541
57542
function toBBox(event) {
57544
 var start = {
57546
   x: event.x - event.dx,
   y: event.y - event.dy
 };
57550
 var end = {
   x: event.x,
   y: event.y
 };
57555
 var bbox;
57557
 if ((start.x <= end.x && start.y < end.y) ||
     (start.x < end.x && start.y <= end.y)) {
57560
   bbox = {
     x: start.x,
     y: start.y,
     width:  end.x - start.x,
     height: end.y - start.y
   };
 } else if ((start.x >= end.x && start.y < end.y) ||
            (start.x > end.x && start.y <= end.y)) {
57569
   bbox = {
     x: end.x,
     y: start.y,
     width:  start.x - end.x,
     height: end.y - start.y
   };
 } else if ((start.x <= end.x && start.y > end.y) ||
            (start.x < end.x && start.y >= end.y)) {
57578
   bbox = {
     x: start.x,
     y: end.y,
     width:  end.x - start.x,
     height: start.y - end.y
   };
 } else if ((start.x >= end.x && start.y > end.y) ||
            (start.x > end.x && start.y >= end.y)) {
57587
   bbox = {
     x: end.x,
     y: end.y,
     width:  start.x - end.x,
     height: start.y - end.y
   };
 } else {
57595
   bbox = {
     x: end.x,
     y: end.y,
     width:  0,
     height: 0
   };
 }
 return bbox;
}
57605
var LassoToolModule = {
 __depends__: [
   ToolManagerModule,
   MouseModule
 ],
 __init__: [ 'lassoTool' ],
 lassoTool: [ 'type', LassoTool ]
};
57614
var HIGH_PRIORITY$1 = 1500;
var HAND_CURSOR = 'grab';
57617
57618
function HandTool(
   eventBus, canvas, dragging,
   injector, toolManager, mouse) {
57622
 this._dragging = dragging;
 this._mouse = mouse;
57625
 var self = this,
     keyboard = injector.get('keyboard', false);
57628
 toolManager.registerTool('hand', {
   tool: 'hand',
   dragging: 'hand.move'
 });
57633
 eventBus.on('element.mousedown', HIGH_PRIORITY$1, function(event) {
57635
   if (!hasPrimaryModifier(event)) {
     return;
   }
57639
   self.activateMove(event.originalEvent, true);
57641
   return false;
 });
57644
 keyboard && keyboard.addListener(HIGH_PRIORITY$1, function(e) {
   if (!isSpace(e.keyEvent) || self.isActive()) {
     return;
   }
57649
   var mouseEvent = self._mouse.getLastMoveEvent();
57651
   self.activateMove(mouseEvent, !!mouseEvent);
 }, 'keyboard.keydown');
57654
 keyboard && keyboard.addListener(HIGH_PRIORITY$1, function(e) {
   if (!isSpace(e.keyEvent) || !self.isActive()) {
     return;
   }
57659
   self.toggle();
 }, 'keyboard.keyup');
57662
 eventBus.on('hand.end', function(event) {
   var target = event.originalEvent.target;
57665
   // only reactive on diagram click
   // on some occasions, event.hover is not set and we have to check if the target is an svg
   if (!event.hover && !(target instanceof SVGElement)) {
     return false;
   }
57671
   eventBus.once('hand.ended', function() {
     self.activateMove(event.originalEvent, { reactivate: true });
   });
57675
 });
57677
 eventBus.on('hand.move.move', function(event) {
   var scale = canvas.viewbox().scale;
57680
   canvas.scroll({
     dx: event.dx * scale,
     dy: event.dy * scale
   });
 });
57686
 eventBus.on('hand.move.end', function(event) {
   var context = event.context,
       reactivate = context.reactivate;
57690
   // Don't reactivate if the user is using the keyboard keybinding
   if (!hasPrimaryModifier(event) && reactivate) {
57693
     eventBus.once('hand.move.ended', function(event) {
       self.activateHand(event.originalEvent, true, true);
     });
57697
   }
57699
   return false;
 });
57702
}
57704
HandTool.$inject = [
 'eventBus',
 'canvas',
 'dragging',
 'injector',
 'toolManager',
 'mouse'
];
57713
57714
HandTool.prototype.activateMove = function(event, autoActivate, context) {
 if (typeof autoActivate === 'object') {
   context = autoActivate;
   autoActivate = false;
 }
57720
 this._dragging.init(event, 'hand.move', {
   autoActivate: autoActivate,
   cursor: HAND_CURSOR,
   data: {
     context: context || {}
   }
 });
};
57729
HandTool.prototype.activateHand = function(event, autoActivate, reactivate) {
 this._dragging.init(event, 'hand', {
   trapClick: false,
   autoActivate: autoActivate,
   cursor: HAND_CURSOR,
   data: {
     context: {
       reactivate: reactivate
     }
   }
 });
};
57742
HandTool.prototype.toggle = function() {
 if (this.isActive()) {
   return this._dragging.cancel();
 }
57747
 var mouseEvent = this._mouse.getLastMoveEvent();
57749
 this.activateHand(mouseEvent, !!mouseEvent);
};
57752
HandTool.prototype.isActive = function() {
 var context = this._dragging.context();
57755
 if (context) {
   return /^(hand|hand\.move)$/.test(context.prefix);
 }
57759
 return false;
};
57762
// helpers //////////
57764
function isSpace(keyEvent) {
 return isKey(' ', keyEvent);
}
57768
var HandToolModule = {
 __depends__: [
   ToolManagerModule,
   MouseModule
 ],
 __init__: [ 'handTool' ],
 handTool: [ 'type', HandTool ]
};
57777
var MARKER_OK = 'connect-ok',
   MARKER_NOT_OK = 'connect-not-ok';
57780
/**
* @class
* @constructor
*
* @param {EventBus} eventBus
* @param {Dragging} dragging
* @param {Connect} connect
* @param {Canvas} canvas
* @param {ToolManager} toolManager
* @param {Rules} rules
* @param {Mouse} mouse
*/
function GlobalConnect(
   eventBus, dragging, connect,
   canvas, toolManager, rules,
   mouse) {
57797
 var self = this;
57799
 this._dragging = dragging;
 this._rules = rules;
 this._mouse = mouse;
57803
 toolManager.registerTool('global-connect', {
   tool: 'global-connect',
   dragging: 'global-connect.drag'
 });
57808
 eventBus.on('global-connect.hover', function(event) {
   var context = event.context,
       startTarget = event.hover;
57812
   var canStartConnect = context.canStartConnect = self.canStartConnect(startTarget);
57814
   // simply ignore hover
   if (canStartConnect === null) {
     return;
   }
57819
   context.startTarget = startTarget;
57821
   canvas.addMarker(startTarget, canStartConnect ? MARKER_OK : MARKER_NOT_OK);
 });
57824
57825
 eventBus.on([ 'global-connect.out', 'global-connect.cleanup' ], function(event) {
   var startTarget = event.context.startTarget,
       canStartConnect = event.context.canStartConnect;
57829
   if (startTarget) {
     canvas.removeMarker(startTarget, canStartConnect ? MARKER_OK : MARKER_NOT_OK);
   }
 });
57834
57835
 eventBus.on([ 'global-connect.ended' ], function(event) {
   var context = event.context,
       startTarget = context.startTarget,
       startPosition = {
         x: event.x,
         y: event.y
       };
57843
   var canStartConnect = self.canStartConnect(startTarget);
57845
   if (!canStartConnect) {
     return;
   }
57849
   eventBus.once('element.out', function() {
     eventBus.once([ 'connect.ended', 'connect.canceled' ], function() {
       eventBus.fire('global-connect.drag.ended');
     });
57854
     connect.start(null, startTarget, startPosition);
   });
57857
   return false;
 });
}
57861
GlobalConnect.$inject = [
 'eventBus',
 'dragging',
 'connect',
 'canvas',
 'toolManager',
 'rules',
 'mouse'
];
57871
/**
* Initiates tool activity.
*/
GlobalConnect.prototype.start = function(event, autoActivate) {
 this._dragging.init(event, 'global-connect', {
   autoActivate: autoActivate,
   trapClick: false,
   data: {
     context: {}
   }
 });
};
57884
GlobalConnect.prototype.toggle = function() {
57886
 if (this.isActive()) {
   return this._dragging.cancel();
 }
57890
 var mouseEvent = this._mouse.getLastMoveEvent();
57892
 return this.start(mouseEvent, !!mouseEvent);
};
57895
GlobalConnect.prototype.isActive = function() {
 var context = this._dragging.context();
57898
 return context && /^global-connect/.test(context.prefix);
};
57901
/**
* Check if source shape can initiate connection.
*
* @param  {Shape} startTarget
* @return {boolean}
*/
GlobalConnect.prototype.canStartConnect = function(startTarget) {
 return this._rules.allowed('connection.start', { source: startTarget });
};
57911
var GlobalConnectModule = {
 __depends__: [
   ConnectModule,
   RulesModule$1,
   DraggingModule,
   ToolManagerModule,
   MouseModule
 ],
 globalConnect: [ 'type', GlobalConnect ]
};
57922
/**
* A palette provider for BPMN 2.0 elements.
*/
function PaletteProvider(
   palette, create, elementFactory,
   spaceTool, lassoTool, handTool,
   globalConnect, translate) {
57930
 this._palette = palette;
 this._create = create;
 this._elementFactory = elementFactory;
 this._spaceTool = spaceTool;
 this._lassoTool = lassoTool;
 this._handTool = handTool;
 this._globalConnect = globalConnect;
 this._translate = translate;
57939
 palette.registerProvider(this);
}
57942
PaletteProvider.$inject = [
 'palette',
 'create',
 'elementFactory',
 'spaceTool',
 'lassoTool',
 'handTool',
 'globalConnect',
 'translate'
];
57953
57954
PaletteProvider.prototype.getPaletteEntries = function(element) {
57956
 var actions = {},
     create = this._create,
     elementFactory = this._elementFactory,
     spaceTool = this._spaceTool,
     lassoTool = this._lassoTool,
     handTool = this._handTool,
     globalConnect = this._globalConnect,
     translate = this._translate;
57965
 function createAction(type, group, className, title, options) {
57967
   function createListener(event) {
     var shape = elementFactory.createShape(assign({ type: type }, options));
57970
     if (options) {
       var di = getDi(shape);
       di.isExpanded = options.isExpanded;
     }
57975
     create.start(event, shape);
   }
57978
   var shortType = type.replace(/^bpmn:/, '');
57980
   return {
     group: group,
     className: className,
     title: title || translate('Create {type}', { type: shortType }),
     action: {
       dragstart: createListener,
       click: createListener
     }
   };
 }
57991
 function createSubprocess(event) {
   var subProcess = elementFactory.createShape({
     type: 'bpmn:SubProcess',
     x: 0,
     y: 0,
     isExpanded: true
   });
57999
   var startEvent = elementFactory.createShape({
     type: 'bpmn:StartEvent',
     x: 40,
     y: 82,
     parent: subProcess
   });
58006
   create.start(event, [ subProcess, startEvent ], {
     hints: {
       autoSelect: [ subProcess ]
     }
   });
 }
58013
 function createParticipant(event) {
   create.start(event, elementFactory.createParticipantShape());
 }
58017
 assign(actions, {
   'hand-tool': {
     group: 'tools',
     className: 'bpmn-icon-hand-tool',
     title: translate('Activate the hand tool'),
     action: {
       click: function(event) {
         handTool.activateHand(event);
       }
     }
   },
   'lasso-tool': {
     group: 'tools',
     className: 'bpmn-icon-lasso-tool',
     title: translate('Activate the lasso tool'),
     action: {
       click: function(event) {
         lassoTool.activateSelection(event);
       }
     }
   },
   'space-tool': {
     group: 'tools',
     className: 'bpmn-icon-space-tool',
     title: translate('Activate the create/remove space tool'),
     action: {
       click: function(event) {
         spaceTool.activateSelection(event);
       }
     }
   },
   'global-connect-tool': {
     group: 'tools',
     className: 'bpmn-icon-connection-multi',
     title: translate('Activate the global connect tool'),
     action: {
       click: function(event) {
         globalConnect.start(event);
       }
     }
   },
   'tool-separator': {
     group: 'tools',
     separator: true
   },
   'create.start-event': createAction(
     'bpmn:StartEvent', 'event', 'bpmn-icon-start-event-none',
     translate('Create StartEvent')
   ),
   'create.intermediate-event': createAction(
     'bpmn:IntermediateThrowEvent', 'event', 'bpmn-icon-intermediate-event-none',
     translate('Create Intermediate/Boundary Event')
   ),
   'create.end-event': createAction(
     'bpmn:EndEvent', 'event', 'bpmn-icon-end-event-none',
     translate('Create EndEvent')
   ),
   'create.exclusive-gateway': createAction(
     'bpmn:ExclusiveGateway', 'gateway', 'bpmn-icon-gateway-none',
     translate('Create Gateway')
   ),
   'create.task': createAction(
     'bpmn:Task', 'activity', 'bpmn-icon-task',
     translate('Create Task')
   ),
   'create.data-object': createAction(
     'bpmn:DataObjectReference', 'data-object', 'bpmn-icon-data-object',
     translate('Create DataObjectReference')
   ),
   'create.data-store': createAction(
     'bpmn:DataStoreReference', 'data-store', 'bpmn-icon-data-store',
     translate('Create DataStoreReference')
   ),
   'create.subprocess-expanded': {
     group: 'activity',
     className: 'bpmn-icon-subprocess-expanded',
     title: translate('Create expanded SubProcess'),
     action: {
       dragstart: createSubprocess,
       click: createSubprocess
     }
   },
   'create.participant-expanded': {
     group: 'collaboration',
     className: 'bpmn-icon-participant',
     title: translate('Create Pool/Participant'),
     action: {
       dragstart: createParticipant,
       click: createParticipant
     }
   },
   'create.group': createAction(
     'bpmn:Group', 'artifact', 'bpmn-icon-group',
     translate('Create Group')
   ),
 });
58114
 return actions;
};
58117
var PaletteModule = {
 __depends__: [
   PaletteModule$1,
   CreateModule,
   SpaceToolModule,
   LassoToolModule,
   HandToolModule,
   GlobalConnectModule,
   translate
 ],
 __init__: [ 'paletteProvider' ],
 paletteProvider: [ 'type', PaletteProvider ]
};
58131
var LOW_PRIORITY = 250;
58133
58134
function BpmnReplacePreview(
   eventBus, elementRegistry, elementFactory,
   canvas, previewSupport) {
58138
 CommandInterceptor.call(this, eventBus);
58140
 /**
  * Replace the visuals of all elements in the context which can be replaced
  *
  * @param  {Object} context
  */
 function replaceVisual(context) {
58147
   var replacements = context.canExecute.replacements;
58149
   forEach$2(replacements, function(replacement) {
58151
     var id = replacement.oldElementId;
58153
     var newElement = {
       type: replacement.newElementType
     };
58157
     // if the visual of the element is already replaced
     if (context.visualReplacements[id]) {
       return;
     }
58162
     var element = elementRegistry.get(id);
58164
     assign(newElement, { x: element.x, y: element.y });
58166
     // create a temporary shape
     var tempShape = elementFactory.createShape(newElement);
58169
     canvas.addShape(tempShape, element.parent);
58171
     // select the original SVG element related to the element and hide it
     var gfx = query$1('[data-element-id="' + cssEscape(element.id) + '"]', context.dragGroup);
58174
     if (gfx) {
       attr$1(gfx, { display: 'none' });
     }
58178
     // clone the gfx of the temporary shape and add it to the drag group
     var dragger = previewSupport.addDragger(tempShape, context.dragGroup);
58181
     context.visualReplacements[id] = dragger;
58183
     canvas.removeShape(tempShape);
   });
 }
58187
 /**
  * Restore the original visuals of the previously replaced elements
  *
  * @param  {Object} context
  */
 function restoreVisual(context) {
58194
   var visualReplacements = context.visualReplacements;
58196
   forEach$2(visualReplacements, function(dragger, id) {
58198
     var originalGfx = query$1('[data-element-id="' + cssEscape(id) + '"]', context.dragGroup);
58200
     if (originalGfx) {
       attr$1(originalGfx, { display: 'inline' });
     }
58204
     dragger.remove();
58206
     if (visualReplacements[id]) {
       delete visualReplacements[id];
     }
   });
 }
58212
 eventBus.on('shape.move.move', LOW_PRIORITY, function(event) {
58214
   var context = event.context,
       canExecute = context.canExecute;
58217
   if (!context.visualReplacements) {
     context.visualReplacements = {};
   }
58221
   if (canExecute && canExecute.replacements) {
     replaceVisual(context);
   } else {
     restoreVisual(context);
   }
 });
}
58229
BpmnReplacePreview.$inject = [
 'eventBus',
 'elementRegistry',
 'elementFactory',
 'canvas',
 'previewSupport'
];
58237
inherits$1(BpmnReplacePreview, CommandInterceptor);
58239
var ReplacePreviewModule = {
 __depends__: [
   PreviewSupportModule
 ],
 __init__: [ 'bpmnReplacePreview' ],
 bpmnReplacePreview: [ 'type', BpmnReplacePreview ]
};
58247
var HIGHER_PRIORITY$2 = 1250;
58249
var BOUNDARY_TO_HOST_THRESHOLD = 40;
58251
var TARGET_BOUNDS_PADDING = 20,
   TASK_BOUNDS_PADDING = 10;
58254
var TARGET_CENTER_PADDING = 20;
58256
var AXES = [ 'x', 'y' ];
58258
var abs = Math.abs;
58260
/**
* Snap during connect.
*
* @param {EventBus} eventBus
*/
function BpmnConnectSnapping(eventBus) {
 eventBus.on([
   'connect.hover',
   'connect.move',
   'connect.end',
 ], HIGHER_PRIORITY$2, function(event) {
   var context = event.context,
       canExecute = context.canExecute,
       start = context.start,
       hover = context.hover,
       source = context.source,
       target = context.target;
58278
   // do NOT snap on CMD
   if (event.originalEvent && isCmd(event.originalEvent)) {
     return;
   }
58283
   if (!context.initialConnectionStart) {
     context.initialConnectionStart = context.connectionStart;
   }
58287
   // snap hover
   if (canExecute && hover) {
     snapToShape(event, hover, getTargetBoundsPadding(hover));
   }
58292
   if (hover && isAnyType(canExecute, [
     'bpmn:Association',
     'bpmn:DataInputAssociation',
     'bpmn:DataOutputAssociation',
     'bpmn:SequenceFlow'
   ])) {
     context.connectionStart = mid$2(start);
58300
     // snap hover
     if (isAny(hover, [ 'bpmn:Event', 'bpmn:Gateway' ])) {
       snapToPosition(event, mid$2(hover));
     }
58305
     // snap hover
     if (isAny(hover, [ 'bpmn:Task', 'bpmn:SubProcess' ])) {
       snapToTargetMid(event, hover);
     }
58310
     // snap source and target
     if (is$1(source, 'bpmn:BoundaryEvent') && target === source.host) {
       snapBoundaryEventLoop(event);
     }
58315
   } else if (isType(canExecute, 'bpmn:MessageFlow')) {
58317
     if (is$1(start, 'bpmn:Event')) {
58319
       // snap start
       context.connectionStart = mid$2(start);
     }
58323
     if (is$1(hover, 'bpmn:Event')) {
58325
       // snap hover
       snapToPosition(event, mid$2(hover));
     }
58329
   } else {
58331
     // un-snap source
     context.connectionStart = context.initialConnectionStart;
   }
 });
}
58337
BpmnConnectSnapping.$inject = [ 'eventBus' ];
58339
58340
// helpers //////////
58342
// snap to target if event in target
function snapToShape(event, target, padding) {
 AXES.forEach(function(axis) {
   var dimensionForAxis = getDimensionForAxis(axis, target);
58347
   if (event[ axis ] < target[ axis ] + padding) {
     setSnapped(event, axis, target[ axis ] + padding);
   } else if (event[ axis ] > target[ axis ] + dimensionForAxis - padding) {
     setSnapped(event, axis, target[ axis ] + dimensionForAxis - padding);
   }
 });
}
58355
// snap to target mid if event in target mid
function snapToTargetMid(event, target) {
 var targetMid = mid$2(target);
58359
 AXES.forEach(function(axis) {
   if (isMid(event, target, axis)) {
     setSnapped(event, axis, targetMid[ axis ]);
   }
 });
}
58366
// snap to prevent loop overlapping boundary event
function snapBoundaryEventLoop(event) {
 var context = event.context,
     source = context.source,
     target = context.target;
58372
 if (isReverse(context)) {
   return;
 }
58376
 var sourceMid = mid$2(source),
     orientation = getOrientation(sourceMid, target, -10),
     axes = [];
58380
 if (/top|bottom/.test(orientation)) {
   axes.push('x');
 }
58384
 if (/left|right/.test(orientation)) {
   axes.push('y');
 }
58388
 axes.forEach(function(axis) {
   var coordinate = event[ axis ], newCoordinate;
58391
   if (abs(coordinate - sourceMid[ axis ]) < BOUNDARY_TO_HOST_THRESHOLD) {
     if (coordinate > sourceMid[ axis ]) {
       newCoordinate = sourceMid[ axis ] + BOUNDARY_TO_HOST_THRESHOLD;
     }
     else {
       newCoordinate = sourceMid[ axis ] - BOUNDARY_TO_HOST_THRESHOLD;
     }
58399
     setSnapped(event, axis, newCoordinate);
   }
 });
}
58404
function snapToPosition(event, position) {
 setSnapped(event, 'x', position.x);
 setSnapped(event, 'y', position.y);
}
58409
function isType(attrs, type) {
 return attrs && attrs.type === type;
}
58413
function isAnyType(attrs, types) {
 return some(types, function(type) {
   return isType(attrs, type);
 });
}
58419
function getDimensionForAxis(axis, element) {
 return axis === 'x' ? element.width : element.height;
}
58423
function getTargetBoundsPadding(target) {
 if (is$1(target, 'bpmn:Task')) {
   return TASK_BOUNDS_PADDING;
 } else {
   return TARGET_BOUNDS_PADDING;
 }
}
58431
function isMid(event, target, axis) {
 return event[ axis ] > target[ axis ] + TARGET_CENTER_PADDING
   && event[ axis ] < target[ axis ] + getDimensionForAxis(axis, target) - TARGET_CENTER_PADDING;
}
58436
function isReverse(context) {
 var hover = context.hover,
     source = context.source;
58440
 return hover && source && hover === source;
}
58443
/**
* A snap context, containing the (possibly incomplete)
* mappings of drop targets (to identify the snapping)
* to computed snap points.
*/
function SnapContext() {
58450
 /**
  * Map<String, SnapPoints> mapping drop targets to
  * a list of possible snappings.
  *
  * @type {Object}
  */
 this._targets = {};
58458
 /**
  * Map<String, Point> initial positioning of element
  * regarding various snap directions.
  *
  * @type {Object}
  */
 this._snapOrigins = {};
58466
 /**
  * List of snap locations
  *
  * @type {Array<string>}
  */
 this._snapLocations = [];
58473
 /**
  * Map<String, Array<Point>> of default snapping locations
  *
  * @type {Object}
  */
 this._defaultSnaps = {};
}
58481
58482
SnapContext.prototype.getSnapOrigin = function(snapLocation) {
 return this._snapOrigins[snapLocation];
};
58486
58487
SnapContext.prototype.setSnapOrigin = function(snapLocation, initialValue) {
 this._snapOrigins[snapLocation] = initialValue;
58490
 if (this._snapLocations.indexOf(snapLocation) === -1) {
   this._snapLocations.push(snapLocation);
 }
};
58495
58496
SnapContext.prototype.addDefaultSnap = function(type, point) {
58498
 var snapValues = this._defaultSnaps[type];
58500
 if (!snapValues) {
   snapValues = this._defaultSnaps[type] = [];
 }
58504
 snapValues.push(point);
};
58507
/**
* Return a number of initialized snaps, i.e. snap locations such as
* top-left, mid, bottom-right and so forth.
*
* @return {Array<string>} snapLocations
*/
SnapContext.prototype.getSnapLocations = function() {
 return this._snapLocations;
};
58517
/**
* Set the snap locations for this context.
*
* The order of locations determines precedence.
*
* @param {Array<string>} snapLocations
*/
SnapContext.prototype.setSnapLocations = function(snapLocations) {
 this._snapLocations = snapLocations;
};
58528
/**
* Get snap points for a given target
*
* @param {Element|string} target
*/
SnapContext.prototype.pointsForTarget = function(target) {
58535
 var targetId = target.id || target;
58537
 var snapPoints = this._targets[targetId];
58539
 if (!snapPoints) {
   snapPoints = this._targets[targetId] = new SnapPoints();
   snapPoints.initDefaults(this._defaultSnaps);
 }
58544
 return snapPoints;
};
58547
58548
/**
* Creates the snap points and initializes them with the
* given default values.
*
* @param {Object<string, Array<Point>>} [defaultPoints]
*/
function SnapPoints(defaultSnaps) {
58556
 /**
  * Map<String, Map<(x|y), Array<number>>> mapping snap locations,
  * i.e. top-left, bottom-right, center to actual snap values.
  *
  * @type {Object}
  */
 this._snapValues = {};
}
58565
SnapPoints.prototype.add = function(snapLocation, point) {
58567
 var snapValues = this._snapValues[snapLocation];
58569
 if (!snapValues) {
   snapValues = this._snapValues[snapLocation] = { x: [], y: [] };
 }
58573
 if (snapValues.x.indexOf(point.x) === -1) {
   snapValues.x.push(point.x);
 }
58577
 if (snapValues.y.indexOf(point.y) === -1) {
   snapValues.y.push(point.y);
 }
};
58582
58583
SnapPoints.prototype.snap = function(point, snapLocation, axis, tolerance) {
 var snappingValues = this._snapValues[snapLocation];
58586
 return snappingValues && snapTo(point[axis], snappingValues[axis], tolerance);
};
58589
/**
* Initialize a number of default snapping points.
*
* @param  {Object} defaultSnaps
*/
SnapPoints.prototype.initDefaults = function(defaultSnaps) {
58596
 var self = this;
58598
 forEach$2(defaultSnaps || {}, function(snapPoints, snapLocation) {
   forEach$2(snapPoints, function(point) {
     self.add(snapLocation, point);
   });
 });
};
58605
var HIGHER_PRIORITY$1 = 1250;
58607
58608
/**
* Snap during create and move.
*
* @param {EventBus} elementRegistry
* @param {EventBus} eventBus
* @param {Snapping} snapping
*/
function CreateMoveSnapping(elementRegistry, eventBus, snapping) {
 var self = this;
58618
 this._elementRegistry = elementRegistry;
58620
 eventBus.on([
   'create.start',
   'shape.move.start'
 ], function(event) {
   self.initSnap(event);
 });
58627
 eventBus.on([
   'create.move',
   'create.end',
   'shape.move.move',
   'shape.move.end'
 ], HIGHER_PRIORITY$1, function(event) {
   var context = event.context,
       shape = context.shape,
       snapContext = context.snapContext,
       target = context.target;
58638
   if (event.originalEvent && isCmd(event.originalEvent)) {
     return;
   }
58642
   if (isSnapped(event) || !target) {
     return;
   }
58646
   var snapPoints = snapContext.pointsForTarget(target);
58648
   if (!snapPoints.initialized) {
     snapPoints = self.addSnapTargetPoints(snapPoints, shape, target);
58651
     snapPoints.initialized = true;
   }
58654
   snapping.snap(event, snapPoints);
 });
58657
 eventBus.on([
   'create.cleanup',
   'shape.move.cleanup'
 ], function() {
   snapping.hide();
 });
}
58665
CreateMoveSnapping.$inject = [
 'elementRegistry',
 'eventBus',
 'snapping'
];
58671
CreateMoveSnapping.prototype.initSnap = function(event) {
 var elementRegistry = this._elementRegistry;
58674
 var context = event.context,
     shape = context.shape,
     snapContext = context.snapContext;
58678
 if (!snapContext) {
   snapContext = context.snapContext = new SnapContext();
 }
58682
 var shapeMid;
58684
 if (elementRegistry.get(shape.id)) {
58686
   // move
   shapeMid = mid$2(shape, event);
 } else {
58690
   // create
   shapeMid = {
     x: event.x + mid$2(shape).x,
     y: event.y + mid$2(shape).y
   };
 }
58697
 var shapeTopLeft = {
       x: shapeMid.x - shape.width / 2,
       y: shapeMid.y - shape.height / 2
     },
     shapeBottomRight = {
       x: shapeMid.x + shape.width / 2,
       y: shapeMid.y + shape.height / 2
     };
58706
 snapContext.setSnapOrigin('mid', {
   x: shapeMid.x - event.x,
   y: shapeMid.y - event.y
 });
58711
 // snap labels to mid only
 if (isLabel$1(shape)) {
   return snapContext;
 }
58716
 snapContext.setSnapOrigin('top-left', {
   x: shapeTopLeft.x - event.x,
   y: shapeTopLeft.y - event.y
 });
58721
 snapContext.setSnapOrigin('bottom-right', {
   x: shapeBottomRight.x - event.x,
   y: shapeBottomRight.y - event.y
 });
58726
 return snapContext;
};
58729
CreateMoveSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target) {
 var snapTargets = this.getSnapTargets(shape, target);
58732
 forEach$2(snapTargets, function(snapTarget) {
58734
   // handle labels
   if (isLabel$1(snapTarget)) {
58737
     if (isLabel$1(shape)) {
       snapPoints.add('mid', mid$2(snapTarget));
     }
58741
     return;
   }
58744
   // handle connections
   if (isConnection$1(snapTarget)) {
58747
     // ignore single segment connections
     if (snapTarget.waypoints.length < 3) {
       return;
     }
58752
     // ignore first and last waypoint
     var waypoints = snapTarget.waypoints.slice(1, -1);
58755
     forEach$2(waypoints, function(waypoint) {
       snapPoints.add('mid', waypoint);
     });
58759
     return;
   }
58762
   // handle shapes
   snapPoints.add('mid', mid$2(snapTarget));
 });
58766
 if (!isNumber(shape.x) || !isNumber(shape.y)) {
   return snapPoints;
 }
58770
 // snap to original position when moving
 if (this._elementRegistry.get(shape.id)) {
   snapPoints.add('mid', mid$2(shape));
 }
58775
 return snapPoints;
};
58778
CreateMoveSnapping.prototype.getSnapTargets = function(shape, target) {
 return getChildren(target).filter(function(child) {
   return !isHidden$1(child);
 });
};
58784
// helpers //////////
58786
function isConnection$1(element) {
 return !!element.waypoints;
}
58790
function isHidden$1(element) {
 return !!element.hidden;
}
58794
function isLabel$1(element) {
 return !!element.labelTarget;
}
58798
var HIGH_PRIORITY = 1500;
58800
58801
/**
* Snap during create and move.
*
* @param {EventBus} eventBus
* @param {Injector} injector
*/
function BpmnCreateMoveSnapping(eventBus, injector) {
 injector.invoke(CreateMoveSnapping, this);
58810
 // creating first participant
 eventBus.on([ 'create.move', 'create.end' ], HIGH_PRIORITY, setSnappedIfConstrained);
58813
 // snap boundary events
 eventBus.on([
   'create.move',
   'create.end',
   'shape.move.move',
   'shape.move.end'
 ], HIGH_PRIORITY, function(event) {
   var context = event.context,
       canExecute = context.canExecute,
       target = context.target;
58824
   var canAttach = canExecute && (canExecute === 'attach' || canExecute.attach);
58826
   if (canAttach && !isSnapped(event)) {
     snapBoundaryEvent(event, target);
   }
 });
}
58832
inherits$1(BpmnCreateMoveSnapping, CreateMoveSnapping);
58834
BpmnCreateMoveSnapping.$inject = [
 'eventBus',
 'injector'
];
58839
BpmnCreateMoveSnapping.prototype.initSnap = function(event) {
 var snapContext = CreateMoveSnapping.prototype.initSnap.call(this, event);
58842
 var shape = event.shape;
58844
 var isMove = !!this._elementRegistry.get(shape.id);
58846
 // snap to docking points
 forEach$2(shape.outgoing, function(connection) {
   var docking = connection.waypoints[0];
58850
   docking = docking.original || docking;
58852
   snapContext.setSnapOrigin(connection.id + '-docking', getDockingSnapOrigin(docking, isMove, event));
 });
58855
 forEach$2(shape.incoming, function(connection) {
   var docking = connection.waypoints[connection.waypoints.length - 1];
58858
   docking = docking.original || docking;
58860
   snapContext.setSnapOrigin(connection.id + '-docking', getDockingSnapOrigin(docking, isMove, event));
 });
58863
 if (is$1(shape, 'bpmn:Participant')) {
58865
   // snap to borders with higher priority
   snapContext.setSnapLocations([ 'top-left', 'bottom-right', 'mid' ]);
 }
58869
 return snapContext;
};
58872
BpmnCreateMoveSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target) {
 CreateMoveSnapping.prototype.addSnapTargetPoints.call(this, snapPoints, shape, target);
58875
 var snapTargets = this.getSnapTargets(shape, target);
58877
 forEach$2(snapTargets, function(snapTarget) {
58879
   // handle TRBL alignment
   //
   // * with container elements
   // * with text annotations
   if (isContainer(snapTarget) || areAll([ shape, snapTarget ], 'bpmn:TextAnnotation')) {
     snapPoints.add('top-left', topLeft(snapTarget));
     snapPoints.add('bottom-right', bottomRight(snapTarget));
   }
 });
58889
 var elementRegistry = this._elementRegistry;
58891
 // snap to docking points if not create mode
 forEach$2(shape.incoming, function(connection) {
   if (elementRegistry.get(shape.id)) {
58895
     if (!includes(snapTargets, connection.source)) {
       snapPoints.add('mid', getMid(connection.source));
     }
58899
     var docking = connection.waypoints[0];
     snapPoints.add(connection.id + '-docking', docking.original || docking);
   }
 });
58904
 forEach$2(shape.outgoing, function(connection) {
   if (elementRegistry.get(shape.id)) {
58907
     if (!includes(snapTargets, connection.target)) {
       snapPoints.add('mid', getMid(connection.target));
     }
58911
     var docking = connection.waypoints[ connection.waypoints.length - 1 ];
58913
     snapPoints.add(connection.id + '-docking', docking.original || docking);
   }
 });
58917
 // add sequence flow parents as snap targets
 if (is$1(target, 'bpmn:SequenceFlow')) {
   snapPoints = this.addSnapTargetPoints(snapPoints, shape, target.parent);
 }
58922
 return snapPoints;
};
58925
BpmnCreateMoveSnapping.prototype.getSnapTargets = function(shape, target) {
 return CreateMoveSnapping.prototype.getSnapTargets.call(this, shape, target)
   .filter(function(snapTarget) {
58929
     // do not snap to lanes
     return !is$1(snapTarget, 'bpmn:Lane');
   });
};
58934
// helpers //////////
58936
function snapBoundaryEvent(event, target) {
 var targetTRBL = asTRBL(target);
58939
 var direction = getBoundaryAttachment(event, target);
58941
 var context = event.context,
     shape = context.shape;
58944
 var offset;
58946
 if (shape.parent) {
   offset = { x: 0, y: 0 };
 } else {
   offset = getMid(shape);
 }
58952
 if (/top/.test(direction)) {
   setSnapped(event, 'y', targetTRBL.top - offset.y);
 } else if (/bottom/.test(direction)) {
   setSnapped(event, 'y', targetTRBL.bottom - offset.y);
 }
58958
 if (/left/.test(direction)) {
   setSnapped(event, 'x', targetTRBL.left - offset.x);
 } else if (/right/.test(direction)) {
   setSnapped(event, 'x', targetTRBL.right - offset.x);
 }
}
58965
function areAll(elements, type) {
 return elements.every(function(el) {
   return is$1(el, type);
 });
}
58971
function isContainer(element) {
 if (is$1(element, 'bpmn:SubProcess') && isExpanded(element)) {
   return true;
 }
58976
 return is$1(element, 'bpmn:Participant');
}
58979
58980
function setSnappedIfConstrained(event) {
 var context = event.context,
     createConstraints = context.createConstraints;
58984
 if (!createConstraints) {
   return;
 }
58988
 var top = createConstraints.top,
     right = createConstraints.right,
     bottom = createConstraints.bottom,
     left = createConstraints.left;
58993
 if ((left && left >= event.x) || (right && right <= event.x)) {
   setSnapped(event, 'x', event.x);
 }
58997
 if ((top && top >= event.y) || (bottom && bottom <= event.y)) {
   setSnapped(event, 'y', event.y);
 }
}
59002
function includes(array, value) {
 return array.indexOf(value) !== -1;
}
59006
function getDockingSnapOrigin(docking, isMove, event) {
 return isMove ? (
   {
     x: docking.x - event.x,
     y: docking.y - event.y
   }
 ) : {
   x: docking.x,
   y: docking.y
 };
}
59018
var HIGHER_PRIORITY = 1250;
59020
59021
/**
* Snap during resize.
*
* @param {EventBus} eventBus
* @param {Snapping} snapping
*/
function ResizeSnapping(eventBus, snapping) {
 var self = this;
59030
 eventBus.on([ 'resize.start' ], function(event) {
   self.initSnap(event);
 });
59034
 eventBus.on([
   'resize.move',
   'resize.end',
 ], HIGHER_PRIORITY, function(event) {
   var context = event.context,
       shape = context.shape,
       parent = shape.parent,
       direction = context.direction,
       snapContext = context.snapContext;
59044
   if (event.originalEvent && isCmd(event.originalEvent)) {
     return;
   }
59048
   if (isSnapped(event)) {
     return;
   }
59052
   var snapPoints = snapContext.pointsForTarget(parent);
59054
   if (!snapPoints.initialized) {
     snapPoints = self.addSnapTargetPoints(snapPoints, shape, parent, direction);
59057
     snapPoints.initialized = true;
   }
59060
   if (isHorizontal(direction)) {
     setSnapped(event, 'x', event.x);
   }
59064
   if (isVertical(direction)) {
     setSnapped(event, 'y', event.y);
   }
59068
   snapping.snap(event, snapPoints);
 });
59071
 eventBus.on([ 'resize.cleanup' ], function() {
   snapping.hide();
 });
}
59076
ResizeSnapping.prototype.initSnap = function(event) {
 var context = event.context,
     shape = context.shape,
     direction = context.direction,
     snapContext = context.snapContext;
59082
 if (!snapContext) {
   snapContext = context.snapContext = new SnapContext();
 }
59086
 var snapOrigin = getSnapOrigin(shape, direction);
59088
 snapContext.setSnapOrigin('corner', {
   x: snapOrigin.x - event.x,
   y: snapOrigin.y - event.y
 });
59093
 return snapContext;
};
59096
ResizeSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target, direction) {
 var snapTargets = this.getSnapTargets(shape, target);
59099
 forEach$2(snapTargets, function(snapTarget) {
   snapPoints.add('corner', bottomRight(snapTarget));
   snapPoints.add('corner', topLeft(snapTarget));
 });
59104
 snapPoints.add('corner', getSnapOrigin(shape, direction));
59106
 return snapPoints;
};
59109
ResizeSnapping.$inject = [
 'eventBus',
 'snapping'
];
59114
ResizeSnapping.prototype.getSnapTargets = function(shape, target) {
 return getChildren(target).filter(function(child) {
   return !isAttached(child, shape)
     && !isConnection(child)
     && !isHidden(child)
     && !isLabel(child);
 });
};
59123
// helpers //////////
59125
function getSnapOrigin(shape, direction) {
 var mid = getMid(shape),
     trbl = asTRBL(shape);
59129
 var snapOrigin = {
   x: mid.x,
   y: mid.y
 };
59134
 if (direction.indexOf('n') !== -1) {
   snapOrigin.y = trbl.top;
 } else if (direction.indexOf('s') !== -1) {
   snapOrigin.y = trbl.bottom;
 }
59140
 if (direction.indexOf('e') !== -1) {
   snapOrigin.x = trbl.right;
 } else if (direction.indexOf('w') !== -1) {
   snapOrigin.x = trbl.left;
 }
59146
 return snapOrigin;
}
59149
function isAttached(element, host) {
 return element.host === host;
}
59153
function isConnection(element) {
 return !!element.waypoints;
}
59157
function isHidden(element) {
 return !!element.hidden;
}
59161
function isLabel(element) {
 return !!element.labelTarget;
}
59165
function isHorizontal(direction) {
 return direction === 'n' || direction === 's';
}
59169
function isVertical(direction) {
 return direction === 'e' || direction === 'w';
}
59173
var SNAP_TOLERANCE = 7;
59175
var SNAP_LINE_HIDE_DELAY = 1000;
59177
59178
/**
* Generic snapping feature.
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
*/
function Snapping(canvas) {
 this._canvas = canvas;
59187
 // delay hide by 1000 seconds since last snap
 this._asyncHide = debounce(bind(this.hide, this), SNAP_LINE_HIDE_DELAY);
}
59191
Snapping.$inject = [ 'canvas' ];
59193
/**
* Snap an event to given snap points.
*
* @param {Event} event
* @param {SnapPoints} snapPoints
*/
Snapping.prototype.snap = function(event, snapPoints) {
 var context = event.context,
     snapContext = context.snapContext,
     snapLocations = snapContext.getSnapLocations();
59204
 var snapping = {
   x: isSnapped(event, 'x'),
   y: isSnapped(event, 'y')
 };
59209
 forEach$2(snapLocations, function(location) {
   var snapOrigin = snapContext.getSnapOrigin(location);
59212
   var snapCurrent = {
     x: event.x + snapOrigin.x,
     y: event.y + snapOrigin.y
   };
59217
   // snap both axis if not snapped already
   forEach$2([ 'x', 'y' ], function(axis) {
     var locationSnapping;
59221
     if (!snapping[axis]) {
       locationSnapping = snapPoints.snap(snapCurrent, location, axis, SNAP_TOLERANCE);
59224
       if (locationSnapping !== undefined) {
         snapping[axis] = {
           value: locationSnapping,
           originValue: locationSnapping - snapOrigin[axis]
         };
       }
     }
   });
59233
   // no need to continue snapping
   if (snapping.x && snapping.y) {
     return false;
   }
 });
59239
 // show snap lines
 this.showSnapLine('vertical', snapping.x && snapping.x.value);
 this.showSnapLine('horizontal', snapping.y && snapping.y.value);
59243
 // snap event
 forEach$2([ 'x', 'y' ], function(axis) {
   var axisSnapping = snapping[axis];
59247
   if (isObject(axisSnapping)) {
     setSnapped(event, axis, axisSnapping.originValue);
   }
 });
};
59253
Snapping.prototype._createLine = function(orientation) {
 var root = this._canvas.getLayer('snap');
59256
 var line = create$1('path');
59258
 attr$1(line, { d: 'M0,0 L0,0' });
59260
 classes$1(line).add('djs-snap-line');
59262
 append(root, line);
59264
 return {
   update: function(position) {
59267
     if (!isNumber(position)) {
       attr$1(line, { display: 'none' });
     } else {
       if (orientation === 'horizontal') {
         attr$1(line, {
           d: 'M-100000,' + position + ' L+100000,' + position,
           display: ''
         });
       } else {
         attr$1(line, {
           d: 'M ' + position + ',-100000 L ' + position + ', +100000',
           display: ''
         });
       }
     }
   }
 };
};
59286
Snapping.prototype._createSnapLines = function() {
 this._snapLines = {
   horizontal: this._createLine('horizontal'),
   vertical: this._createLine('vertical')
 };
};
59293
Snapping.prototype.showSnapLine = function(orientation, position) {
59295
 var line = this.getSnapLine(orientation);
59297
 if (line) {
   line.update(position);
 }
59301
 this._asyncHide();
};
59304
Snapping.prototype.getSnapLine = function(orientation) {
 if (!this._snapLines) {
   this._createSnapLines();
 }
59309
 return this._snapLines[orientation];
};
59312
Snapping.prototype.hide = function() {
 forEach$2(this._snapLines, function(snapLine) {
   snapLine.update();
 });
};
59318
var SnappingModule$1 = {
 __init__: [
   'createMoveSnapping',
   'resizeSnapping',
   'snapping'
 ],
 createMoveSnapping: [ 'type', CreateMoveSnapping ],
 resizeSnapping: [ 'type', ResizeSnapping ],
 snapping: [ 'type', Snapping ]
};
59329
var SnappingModule = {
 __depends__: [ SnappingModule$1 ],
 __init__: [
   'connectSnapping',
   'createMoveSnapping'
 ],
 connectSnapping: [ 'type', BpmnConnectSnapping ],
 createMoveSnapping: [ 'type', BpmnCreateMoveSnapping ]
};
59339
/**
* Provides searching infrastructure
*/
function SearchPad(canvas, eventBus, overlays, selection) {
 this._open = false;
 this._results = [];
 this._eventMaps = [];
59347
 this._canvas = canvas;
 this._eventBus = eventBus;
 this._overlays = overlays;
 this._selection = selection;
59352
 // setup elements
 this._container = domify(SearchPad.BOX_HTML);
 this._searchInput = query(SearchPad.INPUT_SELECTOR, this._container);
 this._resultsContainer = query(SearchPad.RESULTS_CONTAINER_SELECTOR, this._container);
59357
 // attach search pad
 this._canvas.getContainer().appendChild(this._container);
59360
 // cleanup on destroy
 eventBus.on([ 'canvas.destroy', 'diagram.destroy' ], this.close, this);
}
59364
59365
SearchPad.$inject = [
 'canvas',
 'eventBus',
 'overlays',
 'selection'
];
59372
59373
/**
* Binds and keeps track of all event listereners
*/
SearchPad.prototype._bindEvents = function() {
 var self = this;
59379
 function listen(el, selector, type, fn) {
   self._eventMaps.push({
     el: el,
     type: type,
     listener: delegate.bind(el, selector, type, fn)
   });
 }
59387
 // close search on clicking anywhere outside
 listen(document, 'html', 'click', function(e) {
   self.close();
 });
59392
 // stop event from propagating and closing search
 // focus on input
 listen(this._container, SearchPad.INPUT_SELECTOR, 'click', function(e) {
   e.stopPropagation();
   e.delegateTarget.focus();
 });
59399
 // preselect result on hover
 listen(this._container, SearchPad.RESULT_SELECTOR, 'mouseover', function(e) {
   e.stopPropagation();
   self._scrollToNode(e.delegateTarget);
   self._preselect(e.delegateTarget);
 });
59406
 // selects desired result on mouse click
 listen(this._container, SearchPad.RESULT_SELECTOR, 'click', function(e) {
   e.stopPropagation();
   self._select(e.delegateTarget);
 });
59412
 // prevent cursor in input from going left and right when using up/down to
 // navigate results
 listen(this._container, SearchPad.INPUT_SELECTOR, 'keydown', function(e) {
59416
   // up
   if (e.keyCode === 38) {
     e.preventDefault();
   }
59421
   // down
   if (e.keyCode === 40) {
     e.preventDefault();
   }
 });
59427
 // handle keyboard input
 listen(this._container, SearchPad.INPUT_SELECTOR, 'keyup', function(e) {
59430
   // escape
   if (e.keyCode === 27) {
     return self.close();
   }
59435
   // enter
   if (e.keyCode === 13) {
     var selected = self._getCurrentResult();
59439
     return selected ? self._select(selected) : self.close();
   }
59442
   // up
   if (e.keyCode === 38) {
     return self._scrollToDirection(true);
   }
59447
   // down
   if (e.keyCode === 40) {
     return self._scrollToDirection();
   }
59452
   // left && right
   // do not search while navigating text input
   if (e.keyCode === 37 || e.keyCode === 39) {
     return;
   }
59458
   // anything else
   self._search(e.delegateTarget.value);
 });
};
59463
59464
/**
* Unbinds all previously established listeners
*/
SearchPad.prototype._unbindEvents = function() {
 this._eventMaps.forEach(function(m) {
   delegate.unbind(m.el, m.type, m.listener);
 });
};
59473
59474
/**
* Performs a search for the given pattern.
*
* @param  {string} pattern
*/
SearchPad.prototype._search = function(pattern) {
 var self = this;
59482
 this._clearResults();
59484
 // do not search on empty query
 if (!pattern || pattern === '') {
   return;
 }
59489
 var searchResults = this._searchProvider.find(pattern);
59491
 if (!searchResults.length) {
   return;
 }
59495
 // append new results
 searchResults.forEach(function(result) {
   var id = result.element.id;
   var node = self._createResultNode(result, id);
   self._results[id] = {
     element: result.element,
     node: node
   };
 });
59505
 // preselect first result
 var node = query(SearchPad.RESULT_SELECTOR, this._resultsContainer);
 this._scrollToNode(node);
 this._preselect(node);
};
59511
59512
/**
* Navigate to the previous/next result. Defaults to next result.
* @param  {boolean} previous
*/
SearchPad.prototype._scrollToDirection = function(previous) {
 var selected = this._getCurrentResult();
 if (!selected) {
   return;
 }
59522
 var node = previous ? selected.previousElementSibling : selected.nextElementSibling;
 if (node) {
   this._scrollToNode(node);
   this._preselect(node);
 }
};
59529
59530
/**
* Scroll to the node if it is not visible.
*
* @param  {Element} node
*/
SearchPad.prototype._scrollToNode = function(node) {
 if (!node || node === this._getCurrentResult()) {
   return;
 }
59540
 var nodeOffset = node.offsetTop;
 var containerScroll = this._resultsContainer.scrollTop;
59543
 var bottomScroll = nodeOffset - this._resultsContainer.clientHeight + node.clientHeight;
59545
 if (nodeOffset < containerScroll) {
   this._resultsContainer.scrollTop = nodeOffset;
 } else if (containerScroll < bottomScroll) {
   this._resultsContainer.scrollTop = bottomScroll;
 }
};
59552
59553
/**
* Clears all results data.
*/
SearchPad.prototype._clearResults = function() {
 clear(this._resultsContainer);
59559
 this._results = [];
59561
 this._resetOverlay();
59563
 this._eventBus.fire('searchPad.cleared');
};
59566
59567
/**
* Get currently selected result.
*
* @return {Element}
*/
SearchPad.prototype._getCurrentResult = function() {
 return query(SearchPad.RESULT_SELECTED_SELECTOR, this._resultsContainer);
};
59576
59577
/**
* Create result DOM element within results container
* that corresponds to a search result.
*
* 'result' : one of the elements returned by SearchProvider
* 'id' : id attribute value to assign to the new DOM node
* return : created DOM element
*
* @param  {SearchResult} result
* @param  {string} id
* @return {Element}
*/
SearchPad.prototype._createResultNode = function(result, id) {
 var node = domify(SearchPad.RESULT_HTML);
59592
 // create only if available
 if (result.primaryTokens.length > 0) {
   createInnerTextNode(node, result.primaryTokens, SearchPad.RESULT_PRIMARY_HTML);
 }
59597
 // secondary tokens (represent element ID) are allways available
 createInnerTextNode(node, result.secondaryTokens, SearchPad.RESULT_SECONDARY_HTML);
59600
 attr(node, SearchPad.RESULT_ID_ATTRIBUTE, id);
59602
 this._resultsContainer.appendChild(node);
59604
 return node;
};
59607
59608
/**
* Register search element provider.
*
* SearchProvider.find - provides search function over own elements
*  (pattern) => [{ text: <String>, element: <Element>}, ...]
*
* @param  {SearchProvider} provider
*/
SearchPad.prototype.registerProvider = function(provider) {
 this._searchProvider = provider;
};
59620
59621
/**
* Open search pad.
*/
SearchPad.prototype.open = function() {
 if (!this._searchProvider) {
   throw new Error('no search provider registered');
 }
59629
 if (this.isOpen()) {
   return;
 }
59633
 this._bindEvents();
59635
 this._open = true;
59637
 classes(this._container).add('open');
59639
 this._searchInput.focus();
59641
 this._eventBus.fire('searchPad.opened');
};
59644
59645
/**
* Close search pad.
*/
SearchPad.prototype.close = function() {
 if (!this.isOpen()) {
   return;
 }
59653
 this._unbindEvents();
59655
 this._open = false;
59657
 classes(this._container).remove('open');
59659
 this._clearResults();
59661
 this._searchInput.value = '';
 this._searchInput.blur();
59664
 this._resetOverlay();
59666
 this._eventBus.fire('searchPad.closed');
};
59669
59670
/**
* Toggles search pad on/off.
*/
SearchPad.prototype.toggle = function() {
 this.isOpen() ? this.close() : this.open();
};
59677
59678
/**
* Report state of search pad.
*/
SearchPad.prototype.isOpen = function() {
 return this._open;
};
59685
59686
/**
* Preselect result entry.
*
* @param  {Element} element
*/
SearchPad.prototype._preselect = function(node) {
 var selectedNode = this._getCurrentResult();
59694
 // already selected
 if (node === selectedNode) {
   return;
 }
59699
 // removing preselection from current node
 if (selectedNode) {
   classes(selectedNode).remove(SearchPad.RESULT_SELECTED_CLASS);
 }
59704
 var id = attr(node, SearchPad.RESULT_ID_ATTRIBUTE);
 var element = this._results[id].element;
59707
 classes(node).add(SearchPad.RESULT_SELECTED_CLASS);
59709
 this._resetOverlay(element);
59711
 this._canvas.scrollToElement(element, { top: 400 });
59713
 this._selection.select(element);
59715
 this._eventBus.fire('searchPad.preselected', element);
};
59718
59719
/**
* Select result node.
*
* @param  {Element} element
*/
SearchPad.prototype._select = function(node) {
 var id = attr(node, SearchPad.RESULT_ID_ATTRIBUTE);
 var element = this._results[id].element;
59728
 this.close();
59730
 this._resetOverlay();
59732
 this._canvas.scrollToElement(element, { top: 400 });
59734
 this._selection.select(element);
59736
 this._eventBus.fire('searchPad.selected', element);
};
59739
59740
/**
* Reset overlay removes and, optionally, set
* overlay to a new element.
*
* @param  {Element} element
*/
SearchPad.prototype._resetOverlay = function(element) {
 if (this._overlayId) {
   this._overlays.remove(this._overlayId);
 }
59751
 if (element) {
   var box = getBBox(element);
   var overlay = constructOverlay(box);
   this._overlayId = this._overlays.add(element, overlay);
 }
};
59758
59759
/**
* Construct overlay object for the given bounding box.
*
* @param  {BoundingBox} box
* @return {Object}
*/
function constructOverlay(box) {
59767
 var offset = 6;
 var w = box.width + offset * 2;
 var h = box.height + offset * 2;
59771
 var styles = {
   width: w + 'px',
   height: h + 'px'
 };
59776
 var html = domify('<div class="' + SearchPad.OVERLAY_CLASS + '"></div>');
59778
 assign$1(html, styles);
59780
 return {
   position: {
     bottom: h - offset,
     right: w - offset
   },
   show: true,
   html: html
 };
}
59790
59791
/**
* Creates and appends child node from result tokens and HTML template.
*
* @param  {Element} node
* @param  {Array<Object>} tokens
* @param  {string} template
*/
function createInnerTextNode(parentNode, tokens, template) {
 var text = createHtmlText(tokens);
 var childNode = domify(template);
 childNode.innerHTML = text;
 parentNode.appendChild(childNode);
}
59805
/**
* Create internal HTML markup from result tokens.
* Caters for highlighting pattern matched tokens.
*
* @param  {Array<Object>} tokens
* @return {string}
*/
function createHtmlText(tokens) {
 var htmlText = '';
59815
 tokens.forEach(function(t) {
   if (t.matched) {
     htmlText += '<strong class="' + SearchPad.RESULT_HIGHLIGHT_CLASS + '">' + escapeHTML(t.matched) + '</strong>';
   } else {
     htmlText += escapeHTML(t.normal);
   }
 });
59823
 return htmlText !== '' ? htmlText : null;
}
59826
59827
/**
* CONSTANTS
*/
SearchPad.CONTAINER_SELECTOR = '.djs-search-container';
SearchPad.INPUT_SELECTOR = '.djs-search-input input';
SearchPad.RESULTS_CONTAINER_SELECTOR = '.djs-search-results';
SearchPad.RESULT_SELECTOR = '.djs-search-result';
SearchPad.RESULT_SELECTED_CLASS = 'djs-search-result-selected';
SearchPad.RESULT_SELECTED_SELECTOR = '.' + SearchPad.RESULT_SELECTED_CLASS;
SearchPad.RESULT_ID_ATTRIBUTE = 'data-result-id';
SearchPad.RESULT_HIGHLIGHT_CLASS = 'djs-search-highlight';
SearchPad.OVERLAY_CLASS = 'djs-search-overlay';
59840
SearchPad.BOX_HTML =
 '<div class="djs-search-container djs-draggable djs-scrollable">' +
   '<div class="djs-search-input">' +
     '<input type="text"/>' +
   '</div>' +
   '<div class="djs-search-results"></div>' +
 '</div>';
59848
SearchPad.RESULT_HTML =
 '<div class="djs-search-result"></div>';
59851
SearchPad.RESULT_PRIMARY_HTML =
 '<div class="djs-search-result-primary"></div>';
59854
SearchPad.RESULT_SECONDARY_HTML =
 '<p class="djs-search-result-secondary"></p>';
59857
var SearchPadModule = {
 __depends__: [
   OverlaysModule,
   SelectionModule
 ],
 searchPad: [ 'type', SearchPad ]
};
59865
/**
* Provides ability to search through BPMN elements
*/
function BpmnSearchProvider(elementRegistry, searchPad, canvas) {
59870
 this._elementRegistry = elementRegistry;
 this._canvas = canvas;
59873
 searchPad.registerProvider(this);
}
59876
BpmnSearchProvider.$inject = [
 'elementRegistry',
 'searchPad',
 'canvas'
];
59882
59883
/**
* Finds all elements that match given pattern
*
* <Result> :
*  {
*    primaryTokens: <Array<Token>>,
*    secondaryTokens: <Array<Token>>,
*    element: <Element>
*  }
*
* <Token> :
*  {
*    normal|matched: <string>
*  }
*
* @param  {string} pattern
* @return {Array<Result>}
*/
BpmnSearchProvider.prototype.find = function(pattern) {
 var rootElement = this._canvas.getRootElement();
59904
 var elements = this._elementRegistry.filter(function(element) {
   if (element.labelTarget) {
     return false;
   }
   return true;
 });
59911
 // do not include root element
 elements = filter(elements, function(element) {
   return element !== rootElement;
 });
59916
 elements = map(elements, function(element) {
   return {
     primaryTokens: matchAndSplit(getLabel(element), pattern),
     secondaryTokens: matchAndSplit(element.id, pattern),
     element: element
   };
 });
59924
 // exclude non-matched elements
 elements = filter(elements, function(element) {
   return hasMatched(element.primaryTokens) || hasMatched(element.secondaryTokens);
 });
59929
 elements = sortBy(elements, function(element) {
   return getLabel(element.element) + element.element.id;
 });
59933
 return elements;
};
59936
59937
function hasMatched(tokens) {
 var matched = filter(tokens, function(t) {
   return !!t.matched;
 });
59942
 return matched.length > 0;
}
59945
59946
function matchAndSplit(text, pattern) {
 var tokens = [],
     originalText = text;
59950
 if (!text) {
   return tokens;
 }
59954
 text = text.toLowerCase();
 pattern = pattern.toLowerCase();
59957
 var i = text.indexOf(pattern);
59959
 if (i > -1) {
   if (i !== 0) {
     tokens.push({
       normal: originalText.substr(0, i)
     });
   }
59966
   tokens.push({
     matched: originalText.substr(i, pattern.length)
   });
59970
   if (pattern.length + i < text.length) {
     tokens.push({
       normal: originalText.substr(pattern.length + i, text.length)
     });
   }
 } else {
   tokens.push({
     normal: originalText
   });
 }
59981
 return tokens;
}
59984
var SearchModule = {
 __depends__: [
   SearchPadModule
 ],
 __init__: [ 'bpmnSearch'],
 bpmnSearch: [ 'type', BpmnSearchProvider ]
};
59992
var initialDiagram =
 '<?xml version="1.0" encoding="UTF-8"?>' +
 '<bpmn:definitions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' +
                   'xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" ' +
                   'xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" ' +
                   'xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" ' +
                   'targetNamespace="http://bpmn.io/schema/bpmn" ' +
                   'id="Definitions_1">' +
   '<bpmn:process id="Process_1" isExecutable="false">' +
     '<bpmn:startEvent id="StartEvent_1"/>' +
   '</bpmn:process>' +
   '<bpmndi:BPMNDiagram id="BPMNDiagram_1">' +
     '<bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1">' +
       '<bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">' +
         '<dc:Bounds height="36.0" width="36.0" x="173.0" y="102.0"/>' +
       '</bpmndi:BPMNShape>' +
     '</bpmndi:BPMNPlane>' +
   '</bpmndi:BPMNDiagram>' +
 '</bpmn:definitions>';
60012
60013
/**
* A modeler for BPMN 2.0 diagrams.
*
*
* ## Extending the Modeler
*
* In order to extend the viewer pass extension modules to bootstrap via the
* `additionalModules` option. An extension module is an object that exposes
* named services.
*
* The following example depicts the integration of a simple
* logging component that integrates with interaction events:
*
*
* ```javascript
*
* // logging component
* function InteractionLogger(eventBus) {
*   eventBus.on('element.hover', function(event) {
*     console.log()
*   })
* }
*
* InteractionLogger.$inject = [ 'eventBus' ]; // minification save
*
* // extension module
* var extensionModule = {
*   __init__: [ 'interactionLogger' ],
*   interactionLogger: [ 'type', InteractionLogger ]
* };
*
* // extend the viewer
* var bpmnModeler = new Modeler({ additionalModules: [ extensionModule ] });
* bpmnModeler.importXML(...);
* ```
*
*
* ## Customizing / Replacing Components
*
* You can replace individual diagram components by redefining them in override modules.
* This works for all components, including those defined in the core.
*
* Pass in override modules via the `options.additionalModules` flag like this:
*
* ```javascript
* function CustomContextPadProvider(contextPad) {
*
*   contextPad.registerProvider(this);
*
*   this.getContextPadEntries = function(element) {
*     // no entries, effectively disable the context pad
*     return {};
*   };
* }
*
* CustomContextPadProvider.$inject = [ 'contextPad' ];
*
* var overrideModule = {
*   contextPadProvider: [ 'type', CustomContextPadProvider ]
* };
*
* var bpmnModeler = new Modeler({ additionalModules: [ overrideModule ]});
* ```
*
* @param {Object} [options] configuration options to pass to the viewer
* @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.
* @param {string|number} [options.width] the width of the viewer
* @param {string|number} [options.height] the height of the viewer
* @param {Object} [options.moddleExtensions] extension packages to provide
* @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules
* @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules
*/
function Modeler(options) {
 BaseModeler.call(this, options);
}
60089
inherits$1(Modeler, BaseModeler);
60091
60092
Modeler.Viewer = Viewer;
Modeler.NavigatedViewer = NavigatedViewer;
60095
/**
* The createDiagram result.
*
* @typedef {Object} CreateDiagramResult
*
* @property {Array<string>} warnings
*/
60103
/**
* The createDiagram error.
*
* @typedef {Error} CreateDiagramError
*
* @property {Array<string>} warnings
*/
60111
/**
* Create a new diagram to start modeling.
*
* Returns {Promise<CreateDiagramResult, CreateDiagramError>}
*/
Modeler.prototype.createDiagram = wrapForCompatibility(function createDiagram() {
 return this.importXML(initialDiagram);
});
60120
60121
Modeler.prototype._interactionModules = [
60123
 // non-modeling components
 KeyboardMoveModule,
 MoveCanvasModule,
 TouchModule,
 ZoomScrollModule
];
60130
Modeler.prototype._modelingModules = [
60132
 // modeling components
 AlignElementsModule,
 AutoPlaceModule,
 AutoScrollModule,
 AutoResizeModule,
 BendpointsModule,
 ConnectModule,
 ConnectionPreviewModule,
 ContextPadModule,
 CopyPasteModule,
 CreateModule,
 DistributeElementsModule,
 EditorActionsModule,
 GridSnappingModule,
 InteractionEventsModule,
 KeyboardModule,
 KeyboardMoveSelectionModule,
 LabelEditingModule,
 ModelingModule,
 MoveModule,
 PaletteModule,
 ReplacePreviewModule,
 ResizeModule,
 SnappingModule,
 SearchModule
];
60159
60160
// modules the modeler is composed of
//
// - viewer modules
// - interaction modules
// - modeling modules
60166
Modeler.prototype._modules = [].concat(
 Viewer.prototype._modules,
 Modeler.prototype._interactionModules,
 Modeler.prototype._modelingModules
);
60172
return Modeler;
60174
60175})));
1	`/*!`
2	`* bpmn-js - bpmn-modeler v9.1.0`
3	`*`
4	`* Copyright (c) 2014-present, camunda Services GmbH`
5	`*`
6	`* Released under the bpmn.io license`
7	`* http://bpmn.io/license`
8	`*`
9	`* Source Code: https://github.com/bpmn-io/bpmn-js`
10	`*`
11	`* Date: 2022-05-18`
12	`*/`
13	`(function (global, factory) {`
14	`typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :`
15	`typeof define === 'function' && define.amd ? define(factory) :`
16	`(global = typeof globalThis !== 'undefined' ? globalThis : global \|\| self, global.BpmnJS = factory());`
17	`}(this, (function () { 'use strict';`
18
19	`var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};`
20
21	`var inherits_browser = {exports: {}};`
22
23	`if (typeof Object.create === 'function') {`
24	`// implementation from standard node.js 'util' module`
25	`inherits_browser.exports = function inherits(ctor, superCtor) {`
26	`if (superCtor) {`
27	`ctor.super_ = superCtor;`
28	`ctor.prototype = Object.create(superCtor.prototype, {`
29	`constructor: {`
30	`value: ctor,`
31	`enumerable: false,`
32	`writable: true,`
33	`configurable: true`
34	`}`
35	`});`
36	`}`
37	`};`
38	`} else {`
39	`// old school shim for old browsers`
40	`inherits_browser.exports = function inherits(ctor, superCtor) {`